node-gman

TypeScript/Node.js SDK for g-mand — TF2 trading daemon.

Installation

npm install node-gman

Quick Start

import { GManClient, TradeOfferManagerAdapter, SteamUserAdapter } from 'node-gman';

// Connect to g-mand daemon
const client = new GManClient({
  netType: 'tcp',           // 'tcp' or 'unix'
  address: '127.0.0.1:50051',
});

// Check status
const status = await client.getStatus();
console.log(`Steam ID: ${status.steam_id}, Connected: ${status.connected}`);

// Create adapters
const steamUser = new SteamUserAdapter(client);
const tradeManager = new TradeOfferManagerAdapter(client, { pollInterval: 30000 });

// Handle new offers
tradeManager.on('newOffer', async (offer) => {
  console.log(`New offer from ${offer.partner}`);
  
  // Accept the offer
  await client.execAction(440, 'accept-offer', { offer_id: offer.tradeofferid });
});

// Start polling
tradeManager.startPolling();

Connection

Via environment variables

GMAN_IPC_NET=tcp
GMAN_IPC_ADDR=127.0.0.1:50051

Via constructor

const client = new GManClient({
  netType: 'unix',
  address: '/home/user/.config/gman/gman.sock',
  autoLaunch: true,            // Spawn daemon automatically if it's not running
  daemonPath: './bin/g-mand'   // Optional: specify path to g-mand binary
});

Auto-detection

• Windows: tcp://127.0.0.1:50051
• Linux/macOS: unix://~/.config/gman/gman.sock

Classes

GManClient

Main gRPC client for communicating with g-mand.

const client = new GManClient(options?);

Methods:

Method	Description
getStatus()	Connection status
playGame(appid)	Launch a game
exitGame()	Exit the game
execAction(appid, action, params)	Execute an action
streamEvents()	Stream events
updateManualPrices(prices)	Update prices
freeMemory()	Free memory
stopDaemon()	Stop daemon
guardCode()	Steam Guard code
guardStatus()	Guard status
guardList()	List confirmations
guardRespond(id, accept)	Respond to confirmation
guardImport(...)	Import Guard secrets
close()	Close connection

SteamUserAdapter

Adapter for Steam connection (emulates steam-user).

const steamUser = new SteamUserAdapter(client);

Events:

• loggedOn — successful login
• webSession — web session established
• error — error occurred

Methods:

• gamesPlayed(appid) — launch a game
• chatMessage(steamID, message) — send a message

TeamFortress2Adapter

Adapter for TF2 Game Coordinator (emulates @tf2autobot/tf2).

const tf2 = new TeamFortress2Adapter(client);

Properties:

• haveGCSession — whether connected to GC

Events:

• connectedToGC — connected to GC
• disconnectedFromGC — disconnected from GC
• itemAcquired — item received
• itemRemoved — item removed
• itemChanged — item changed

Methods:

• craft(assetids, recipe?) — craft items
• useItem(assetid) — use an item
• deleteItem(assetid) — delete an item
• sortBackpack(type) — sort backpack

TradeOfferManagerAdapter

Adapter for managing trade offers. Uses real-time gRPC event streaming (StreamEvents from the daemon) as the primary transport for instant updates, and falls back to polling for maximum reliability.

const tradeManager = new TradeOfferManagerAdapter(client, {
  pollInterval: 30000, // polling interval in ms (fallback backup)
});

Properties:

• pollData — polling data
• pollInterval — polling interval

Events:

• newOffer — new incoming offer (emitted in real-time)
• offerChanged — offer status changed (emitted in real-time)
• poll — polling data updated
• error — error occurred

Methods:

• startPolling() — start real-time event streaming subscription and backup polling interval
• stopPolling() — unsubscribe from event streaming and stop polling interval
• client.execAction(...) — direct g-mand call

SteamCommunityAdapter

Adapter for Steam Community (emulates @tf2autobot/steamcommunity). Supports web session cookie tracking and synchronization.

const community = new SteamCommunityAdapter(client, { steamID: '...' });

Methods:

• setCookie(cookie) — set/track custom cookie string
• setCookies(cookies) — set/track custom cookies array
• getWebSession(callback) — retrieve active web session ID and cookies
• getWebSessionSync() — synchronously retrieve active web session ID and cookies

Types

interface TradeOffer {
  tradeofferid: string;
  partner: string;
  trade_offer_state: number;
  items_to_give?: TradeOfferItem[];
  items_to_receive?: TradeOfferItem[];
  message?: string;
  data?: Record<string, unknown>;
}

interface TradeOfferItem {
  appid: number;
  contextid: string;
  assetid: string;
  amount: number;
}

interface PollData {
  sent: Record<string, number>;
  received: Record<string, number>;
  offerData: Record<string, Record<string, unknown>>;
}

enum ETradeOfferState {
  Invalid = 1,
  Active = 2,
  Accepted = 3,
  Countered = 4,
  Expired = 5,
  Cancelled = 6,
  Declined = 7,
  InvalidItems = 8,
  CreatedNeedsConfirmation = 9,
  InEscrow = 10,
}

g-mand Actions

Available actions via client.execAction(440, action, params):

Trading

Action	Params	Description
send-offer	offer_params (JSON)	Send trade offer
accept-offer	offer_id	Accept offer
decline-offer	offer_id	Decline offer
cancel-offer	offer_id	Cancel offer
check-escrow	offer (JSON)	Check escrow
active-offers	—	Active incoming offers
active-sent-offers	—	Active outgoing offers

Inventory

Action	Params	Description
inventory	—	Get inventory
get-partner-inventory	partner_id	Partner's inventory
item-details	item_id	Item details
sort-backpack	type, sort_type	Sort backpack

Crafting

Action	Params	Description
craft	recipe, items (JSON)	Craft items
craft-metal	type	Combine metal
smelt-weapons	class	Smelt weapons
condense-metal	—	Condense metal
make-change	target_defindex, target_count	Break down metal

Other

Action	Params	Description
send-chat	steam_id, message	Send chat message
price-check	sku	Check item price
backpack-value	—	Backpack value
delete-item	item_id	Delete item
use-item	item_id	Use item
schema	—	Get schema

CLI

# Install
npm install -g node-gman

# Daemon status
gmanctl-node status

# Launch TF2
gmanctl-node play 440

# Send a message
gmanctl-node exec 440 send-chat steam_id=76561198000000000 message=Hello

# Check price
gmanctl-node exec 440 price-check sku=5021;6

# Stop daemon
gmanctl-node stop

# Auto-migrate credentials and secrets from current folder (.env or config.json)
gmanctl-node migrate

Example: Simple Bot

import { GManClient, TradeOfferManagerAdapter, SteamUserAdapter, TeamFortress2Adapter } from 'node-gman';

async function main() {
  const client = new GManClient();
  const status = await client.getStatus();
  
  if (!status.connected) {
    console.error('g-mand is not connected to Steam');
    process.exit(1);
  }

  const steamUser = new SteamUserAdapter(client);
  const tradeManager = new TradeOfferManagerAdapter(client);
  const tf2 = new TeamFortress2Adapter(client);

  // Wait for TF2 GC connection
  await new Promise<void>((resolve) => {
    if (tf2.haveGCSession) resolve();
    else tf2.once('connectedToGC', () => resolve());
  });

  console.log('Bot started');

  tradeManager.on('newOffer', async (offer) => {
    console.log(`Offer from ${offer.partner}`);
    
    try {
      // Accept all offers (example)
      await client.execAction(440, 'accept-offer', { 
        offer_id: offer.tradeofferid 
      });
      console.log(`Offer ${offer.tradeofferid} accepted`);
      
      // Send thank you message
      await client.execAction(440, 'send-chat', {
        steam_id: offer.partner,
        message: 'Thanks for the trade!',
      });
    } catch (err) {
      console.error('Error:', err);
    }
  });

  tradeManager.startPolling();
}

main();

Security & Session Isolation

To keep Steam accounts highly secure, sensitive session tokens (cookies) and shared secrets are never exported over the gRPC / IPC channels to the JS client.

• All authentication session cookies are kept strictly in g-mand daemon memory space.
• The JS emulators (steamcommunity and tradeoffer-manager) route HTTP requests to the daemon via ExecRequest.
• The daemon automatically injects the proper cookies and updates the sessionid parameter on the fly for every request, maintaining seamless compatibility with external frameworks (like tf2autobot) while minimizing the attack surface.

If you really need to access the daemon's IPC channel directly, you can:

1. Execute a GET request via client.execRequest on any Steam page (e.g., /my).
2. In the returned HTTP headers (Headers), intercept the new Set-Cookie headers that Steam, and parse them.

Drop-in Subpackages

To simplify the migration of existing bots (such as tf2autobot), node-gman includes a set of drop-in subpackage replacements in the packages/ directory. These packages fully emulate the API of their original Node.js counterparts, routing actions to the g-mand daemon or resolving them locally:

• @node-gman/steam-totp — replacement for steam-totp (generates 2FA codes locally or via the daemon).
• @node-gman/steam-user — replacement for steam-user (Steam connection via g-mand).
• @node-gman/steamcommunity — replacement for steamcommunity (community web sessions).
• @node-gman/tf2 — replacement for @tf2autobot/tf2 (TF2 Game Coordinator interaction).
• @node-gman/tradeoffer-manager — replacement for @tf2autobot/tradeoffer-manager (real-time trade offers).
• @node-gman/tf2-sku — replacement for @tf2autobot/tf2-sku (item SKU parsing and generation).
• @node-gman/tf2-currencies — replacement for @tf2autobot/tf2-currencies (TF2 currency math and formatting).

Using in Existing Projects

You can drop these replacements into your existing project's package.json using npm aliases:

"dependencies": {
  "steam-totp": "npm:@node-gman/steam-totp@^1.1.0",
  "steam-user": "npm:@node-gman/steam-user@^1.1.0",
  "@tf2autobot/tradeoffer-manager": "npm:@node-gman/tradeoffer-manager@^1.1.0",
  "@tf2autobot/tf2": "npm:@node-gman/tf2@^1.1.0",
  "@tf2autobot/steamcommunity": "npm:@node-gman/steamcommunity@^1.1.0",
  "@tf2autobot/tf2-sku": "npm:@node-gman/tf2-sku@^1.1.0",
  "@tf2autobot/tf2-currencies": "npm:@node-gman/tf2-currencies@^1.1.0"
}

Build & Tests

The library uses static type generation from protobuf files.

# Generate types and compile TypeScript to dist/
npm run build

# Run Jest unit test suite
npm run test

License

BSD-3-Clause