Commands

ReplySource

Where a command was invoked from — SourceMod's *reply source*. Set by the dispatch path and exposed as CommandInvocation.replySource; it is what CommandInvocation.reply routes on. - "server" — the server console or rcon (callerSlot is -1) - "console" — a player's own developer console - "chat" — a ! or / chat trigger

CommandInvocation

The parsed invocation handed to a command callback: who called it, its arguments (multiple typed accessors), and a caller-appropriate reply channel. It is a plain object that captures no native handle, so it MAY be retained and used after an await/.then — a deferred reply (e.g. from inside delay(...).then(...) or an async DB/HTTP call) is safe to call once the awaited work completes. What it captures, though, is the caller's **slot** — not a stable identity. If the original caller disconnects before the deferred reply runs and a different player has since taken that slot, the reply routes to (or targets the console/chat channel of) whoever now occupies it, not the original caller. Prefer replying synchronously where the timing matters, or re-check the caller (e.g. via their user id) before trusting a slot held across a long-running await.

readonly callerSlot: number

readonly replySource: ReplySource

readonly args: string[]

readonly argString: string

readonly argCount: number

arg(n: number): string

argInt(n: number, fallback?: number): number

argFloat(n: number, fallback?: number): number

argsFrom(n: number): string

reply(message: string): void

// `!help` answers in chat; `sm_help` typed at a console answers in that console.
command("sm_help", (cmd) => { cmd.reply("[SM] Commands: …"); return HookResult.Handled; });

replyToChat(message: string): void

replyToConsole(message: string): void

replyT(key: PhraseKey, ...args: (string | number)[]): void

Command

Alias for CommandInvocation — the SourceMod-shaped name for a parsed invocation.

CommandHandler

A command callback: the parsed invocation, plus an optional HookResultValue. SourceMod Plugin_Handled is HookResult.Handled — return it from a command you own (usage errors included; the command was still consumed). Omit the return (void) to continue — the same as returning HookResult.Continue. Engine SUPERCEDE-on-Continue is not this API; chat ! vs / suppress is unchanged.

command

Register a public command in the load window (SourceMod RegConsoleCmd). Callable only while OnPluginStart is running — throws after settle. .admin / .server are the RegAdminCmd / RegServerCmd shapes: name the handler anything.

import { command, ADMFLAG, HookResult } from "@s2script/sdk";
export function OnPluginStart(): void {
  command.admin("sm_kick", ADMFLAG.KICK, kick);
}
function kick(cmd: CommandInvocation): HookResultValue {
  cmd.reply("kicked");
  return HookResult.Handled;
}

admin(name: string, flags: number, handler: CommandHandler): void

server(name: string, handler: CommandHandler): void

onClientCommand(name: string, handler: (slot: number, argString: string) => HookResultValue | void): void

ChatTrigger

A parsed chat trigger: which command + args, and whether it was the silent (/) trigger.

readonly silent: boolean

readonly name: string

readonly argString: string

Commands

Command-registry utilities: dispatch by name, parse/route chat triggers, and enumerate the global registry. Commands themselves are registered in the load window via command.

import { Commands } from "@s2script/sdk";
// sm_help backend: every registered command + its required admin flag mask.
const cmds = Commands.list().slice().sort((a, b) => (a.name < b.name ? -1 : 1));

dispatch(name: string, slot: number, argString: string, replySource?: ReplySource): boolean

parseChatTrigger(message: string): ChatTrigger | null

handleChatTrigger(slot: number, message: string): { silent: boolean; ran: boolean } | null

readonly triggers: { public: string; silent: string }

onClientCommand(name: string, handler: (slot: number, argString: string) => HookResultValue | void): void

// Middle-mouse ping opens the shop, and still places the ping.
command.onClientCommand("player_ping", (slot) => { openShop(slot); });

list(): { name: string; flags: number }[]