TS API

ID generators

Six wrappers around the built-in idgen.Generator. They return the next free value for the corresponding entity; counters are restored from the DB on server start (MAX(id) + 1). Plugins that create an entity on the server side must take the ID via these helpers so it does not collide with existing DB records.

TsAgentGenID()  int64   // entity "agent",  table Agents.Id
TsTaskGenID()   int64   // entity "task",   table Tasks.TaskId
TsCredGenID()   int64   // entity "cred",   table Credentials.CredId
TsScreenGenID() int64   // entity "screen", table Screenshots.ScreenId
TsTargetGenID() int64   // entity "target", table Targets.TargetId
TsFileGenID()   int64   // entity "file",   table Downloads.FileId

---

Agent Functions

TsAgentIsExists

Checks if an agent exists by ID.

TsAgentIsExists(agentId int64) bool

Returns: bool — true if agent exists

---

TsAgentGetById

Reads one in-memory session. The second result is false when the id is unknown or the agent was removed.

TsAgentGetById(agentId int64) (AgentData, bool)

---

TsAgentIdByUID

Linear search for an agent by UID (optional identifier filled by the listener/agent plugin, not overlapping with agentId).

TsAgentIdByUID(uid []byte) (int64, bool)

Returns: the found agentId and true; (0, false) if no agent has this UID or uid is empty.

---

TsAgentList

JSON array of every in-memory session (AgentData as stored, including the session key). An empty server marshals as null, not [].

TsAgentList() (string, error)

---

TsAgentCatalog

JSON array of registered agent types, sorted by name. Each item is {name, listeners, axs}. axs is the agent AxScript and is omitted when empty.

TsAgentCatalog() (string, error)

---

TsAgentCreate

Creates a new agent on first connection.

TsAgentCreate(agentCrc string, agentUid []byte, beat []byte, listenerName string, ExternalIP string, Async bool) (adaptix.AgentData, error)

Parameter	Type	Description
agentCrc	string	CRC/watermark of the agent type
agentUid	[]byte	Unique agent UID (agentId is generated server-side)
beat	[]byte	Initial data from agent (heartbeat)
listenerName	string	Listener name
ExternalIP	string	Agent's external IP
Async	bool	Asynchronous mode

Returns: adaptix.AgentData, error

Events:

• agent.new (Pre/Post hooks)

---

TsAgentProcessData

Processes data received from an agent.

TsAgentProcessData(agentId int64, bodyData []byte) error

Parameter	Type	Description
agentId	int64	Agent ID
bodyData	[]byte	Data from agent

Events: agent.activate (post only), and only when Mark was "Inactive". The mark is cleared, the row is saved, then the post hook runs.

---

TsAgentUpdateData

Updates agent data (sleep, jitter, killdate, workingtime).

TsAgentUpdateData(newAgentData adaptix.AgentData) error

---

TsAgentUpdateDataPartial

Partial update of agent data. updateData is any struct/map that JSON-marshals to an object with keys from the table below; only present fields are applied.

TsAgentUpdateDataPartial(agentId int64, updateData interface{}) error

Supported fields (JSON key → AgentData field):

JSON key	AgentData field	Type
internal_ip	InternalIP	string
external_ip	ExternalIP	string
gmt_offset	GmtOffset	int
acp	ACP	int
oemcp	OemCP	int
pid	Pid	string
tid	Tid	string
arch	Arch	string
elevated	Elevated	bool
process	Process	string
os	Os	int
os_desc	OsDesc	string
domain	Domain	string
computer	Computer	string
username	Username	string
impersonated	Impersonated	string
tags	Tags	string
mark	Mark	string
color	Color	string ("bg-fg" hex, RGB-validated)
listener	Listener	string
a_session_key	SessionKey	string (stored as []byte; not emitted in TYPE_AGENT_UPDATE)
custom_data	CustomData	string (stored as []byte; not emitted in TYPE_AGENT_UPDATE)
sleep	Sleep	uint
jitter	Jitter	uint
working_time	WorkingTime	int (packed: (startH<<24)|(startM<<16)|(endH<<8)|endM)
kill_date	KillDate	int (unix seconds)

Notes:

• Changing Mark is silently ignored if the current mark is already "Terminated" (terminal state).

• Setting Mark = "Disconnect" also updates LastTick to the current time.

• Color accepts "<bg>-<fg>" hex ("#1e3050-#ffffff"); each half is checked as a valid RGB, and an empty half keeps the previous value.

• Empty updateData (no recognized fields) is a no-op: the function returns nil, nothing is written to the DB, no sync packet is sent.

• Fields not listed are ignored. Crc, Id, UID, Name, CreateTime, Async, and TargetId cannot be modified through this API. LastTick changes only as a side effect of Mark = "Disconnect", or through TsAgentSetTick. Active is a runtime flag on the Agent struct, not part of AgentData.

Typical call from a plugin (for example inside OnDispatch for sleep):

ts.TsAgentUpdateDataPartial(agentId, struct {
    Sleep  *uint `json:"sleep"`
    Jitter *uint `json:"jitter"`
}{Sleep: &newSleep, Jitter: &newJitter})

---

TsAgentTerminate

Terminates an agent.

TsAgentTerminate(agentId int64, terminateTaskId int64) error

Actions performed:

1. Cancels all active downloads

2. Stops all tunnels

3. Closes terminals

4. Clears task queues

5. Removes pivot links

Events:

• agent.terminate (Pre/Post hooks)

---

TsAgentSetTick

Updates the agent's last response time.

TsAgentSetTick(agentId int64, listenerName string) error

---

TsAgentConsoleOutput

Outputs a message to the agent console.

TsAgentConsoleOutput(agentId int64, client string, messageType int, message string, clearText string, store bool)

Parameter	Type	Description
agentId	int64	Agent ID
client	string	Initiator operator name (used for filtering in non-team mode)
messageType	int	Message type (5=INFO, 6=ERROR, 7=SUCCESS)
message	string	Message header
clearText	string	Message text
store	bool	Save to the DB

---

TsAgentBuildExecute

Runs an external command during agent build, redirecting output to the build WebSocket channel.

TsAgentBuildExecute(builderId string, workingDir string, env []string, program string, args ...string) error

Parameter	Type	Description
builderId	string	Builder ID (empty string for synchronous execution)
workingDir	string	Working directory for the command
program	string	Executable
args	...string	Command-line arguments

Note: If builderId is empty, the command runs synchronously without output to the WebSocket. Otherwise stdout/stderr are redirected to the build channel.

---

TsAgentBuildLog

Sends a log message to the agent's WebSocket build channel.

TsAgentBuildLog(builderId string, status int, message string) error

Parameter	Type	Description
builderId	string	Builder ID
status	int	Status: BUILD_LOG_NONE=0, INFO=1, ERROR=2, SUCCESS=3
message	string	Message text

---

TsAgentEncryptData / TsAgentDecryptData

Session-key encrypt and decrypt. Both return an error if the agent has been removed.

TsAgentEncryptData(agentId int64, data []byte) ([]byte, error)
TsAgentDecryptData(agentId int64, data []byte) ([]byte, error)

---

TsSetAgentDeliveryFunc / TsRemoveAgentDeliveryFunc / TsGetAgentDeliveryFunc

Per-agent push callback. TsTaskCreate calls it in a goroutine so a listener can deliver a task without waiting for the next poll. DeliveryFunc is func(agentId int64, taskData TaskData) error.

TsSetAgentDeliveryFunc(AgentId int64, fn DeliveryFunc)
TsRemoveAgentDeliveryFunc(AgentId int64)
TsGetAgentDeliveryFunc(AgentId int64) DeliveryFunc

---

TsAgentGetHosted* Functions

Retrieve tasks for sending to an agent. All functions pack tasks while respecting a size limit. They do not write to the agent console — dequeue is not a send. The task queue (HostedQueue) is a safe.PriorityQueue with FIFO inside each priority level; Pop() returns the highest-priority item first.

StatTasks is counted after OnDispatch. Each known task type has its own {Count, Bytes} (Task, Job, Browser, Tunnel, Proxy, Local, Other). Helpers: stats.Commands() (TASK+JOB), stats.Total(), stats.Of(taskType), stat.SizeString().

TsAgentGetHostedAll

Gets all available tasks: regular tasks, tunnel tasks, tunnel data, and pivot tasks.

TsAgentGetHostedAll(agentId int64, maxDataSize int) ([]byte, StatTasks, error)

Parameter	Type	Description
agentId	int64	Agent ID
maxDataSize	int	Maximum data size (bytes)

Returns: Packed bytes, operator-visible note, error.

A nested TsAgentGetHostedAll for a child should not write a console line for that child.

TsAgentGetHostedTasks

Gets hosted tasks without pivot. maxCount <= 0 means unlimited.

TsAgentGetHostedTasks(agentId int64, maxCount int, maxDataSize int) ([]byte, StatTasks, error)

Parameter	Type	Description
agentId	int64	Agent ID
maxCount	int	Max tasks, or <= 0 for unlimited
maxDataSize	int	Max data size in bytes

The teamserver does not write a console line. After a successful send the listener formats its own text from StatTasks and the bytes it actually wrote (FormatByteSize(len(wire))). stats.Packed is size after PackTasks, before listener wrapping.

Framed transports: the listener prints with adaptix.NoteFrameSent / NoteFrameRecv after TsFrameGetChunk or TsFrameGetChunkSticky, or after a completed TsFramePut, TsFramePutDecoded, or TsFramePutStream. TsFrameTakeStatTasks and TsFrameTakeStatRecv fire once per blob.

TsAgentBuildEmptyTasks

Packs an empty task blob with the agent session key.

TsAgentBuildEmptyTasks(agentId int64) ([]byte, error)

---

Task Functions

TsTaskRunningExists

Checks if a task is running.

TsTaskRunningExists(agentId int64, taskId int64) bool

---

TsTaskCreate

Creates a new task.

TsTaskCreate(agentId int64, cmdline string, client string, taskData adaptix.TaskData)

A task created with taskData.Completed = true (a command that finished on the server) does not enter the HostedQueue. It is finalized immediately: task.complete post hook and a sync broadcast.

Events:

• task.create (Pre/Post hooks)

---

TsTaskUpdate

Updates the task with execution results.

TsTaskUpdate(agentId int64, updateData adaptix.TaskData)

Events:

• task.complete (post only) when this update finalizes the task (Completed on a synced task or job). An update that only parks the task for a client hook does not emit it. Cancel goes through TsTaskCancel and does not emit task.complete.

• task.update_job (post only) on every update of a TASK_TYPE_JOB task, before that job is finalized. task.start is declared and is not emitted.

---

TsTaskCancel

Cancels a task — both one still queued and one already dispatched to the agent.

TsTaskCancel(agentId int64, taskId int64) error

Parameter	Type	Description
agentId	int64	Agent ID
taskId	int64	Task ID

• Task still in agent.HostedQueue (not yet taken by TsTaskGetAvailableAll or TsTaskGetAvailableTasks) — removed from the queue and finalized as canceled: Completed=true, MessageType=MESSAGE_ERROR, Message="Task canceled", FinishDate=now; OnComplete runs. Sync tasks are updated in the DB and broadcast as a task update; others are removed from the client.

• Task already dispatched (in agent.RunningTasks) is cancelable too: removed from RunningTasks, TsFrameResetDownstream drops the rest of that downstream session, server AxScript hooks for that task are unregistered, then the same finalization.

---

Frame Manager Functions

Frame Manager is shared infrastructure for protocol-independent fragmentation/reassembly of large messages between server and agent. It extracts the duplicated logic from listener plugins. It supports three upstream-assembly modes, auto-detected from the first call to the corresponding method:

• Byte-offset mode (TsFramePut with totalSize > 0, chunkCount == 0): the caller knows the total size in bytes and addresses by byte offset.

• Chunk-index mode (TsFramePut with chunkCount > 0): the caller knows the chunk count and addresses by chunk index.

• Stream mode (TsFramePutStream): the total size is unknown up front; chunks arrive with an incrementing seqNum, and the isLast flag signals completion.

Encoding/decoding (compression, frame headers) is performed by the plugin. The plugin passes an encode callback to TsFrameGetChunk and decodes the data returned by TsFramePut/TsFramePutStream itself.

---

TsFrameHasPending

Returns true if the agent has outgoing data in its downstream session, tasks in HostedQueue, pivot tasks for child agents, or orphaned TASK/BROWSER tasks in RunningTasks (see the requeue above).

TsFrameHasPending(sessionId int64) bool

---

TsFramePut

Accepts an upstream fragment from the listener and places it into the reassembly buffer. When assembly is complete, returns the assembled raw block (the plugin decodes/decompresses it and calls TsAgentProcessData).

TsFramePut(sessionId int64, index uint32, data []byte, totalSize uint32, chunkCount uint16) (complete bool, nextExpected uint32, received uint32, sackBitmap uint32, assembled []byte)

Parameter	Type	Description
sessionId	string	Session ID (usually agentId)
index	uint32	Byte offset or chunk index (depends on the mode)
data	[]byte	Fragment contents
totalSize	uint32	Full message size (byte-offset mode); 0 for chunk-index mode
chunkCount	uint16	Number of chunks (chunk-index mode); 0 for byte-offset mode

Returns: complete — fully assembled; nextExpected — next expected offset/index; received — how much has been received; sackBitmap — SACK bitmap of acknowledged chunks; assembled — the fully assembled blob (only when complete=true).

---

TsFramePutStream

Accepts an upstream chunk in stream mode. Chunks arrive with an increasing seqNum; out-of-order arrivals are buffered. When a chunk with isLast = true arrives and all preceding seqNums have been collected — the function returns the assembled raw block.

TsFramePutStream(sessionId int64, seqNum uint32, data []byte, isLast bool) (complete bool, assembled []byte)

Parameter	Type	Description
sessionId	int64	Session ID (usually agentId)
seqNum	uint32	Chunk sequence number (starting at 0)
data	[]byte	Chunk contents
isLast	bool	true — this chunk is the last

Returns: complete — the stream is fully assembled; assembled — the assembled data (only when complete=true). Duplicate seqNums are ignored; a repeated TsFramePutStream for an already-finished session returns (true, nil).

---

TsFramePutDecoded

A TsFramePut variant (byte-offset mode): after the reassembly completes, the decode callback is applied to the assembled block. If decoding returns an error — assembled = nil (the listener can drop the session instead of dispatching garbage).

TsFramePutDecoded(sessionId int64, index uint32, data []byte, totalSize uint32, chunkCount uint16, decode func(assembled []byte) ([]byte, error)) (bool, uint32, uint32, uint32, []byte)

Returns: the same values as TsFramePut (complete, nextExpected, received, sackBitmap, assembled), but assembled is the result of decode(assembled).

---

TsFrameGetChunk

Returns the next downstream chunk for an agent. Creates a downstream session on the first call (including pulling tasks from HostedQueue, packing and encrypting by the agent, applying encode).

TsFrameGetChunk(sessionId int64, reqOffset uint32, maxChunkSize int, encode func([]byte) []byte) (total uint32, offset uint32, data []byte, taskNonce uint32, isEmpty bool)

Parameter	Type	Description
sessionId	string	Session ID
reqOffset	uint32	Requested offset
maxChunkSize	int	Max bytes in a chunk (transport-dependent, e.g., 160 for DNS UDP)
encode	func([]byte) []byte	Optional callback to prepare the full payload (compression + frame); nil — no transformation

Returns: total — total payload size, offset — actual chunk offset, data — chunk contents, taskNonce — session nonce (for subsequent ACK), isEmpty — no data to send.

---

TsFrameGetChunkSticky

The downstream session is marked sticky: when maxAttempts is exceeded it is not evicted — the attempt counter resets instead, and the session is released only by the idle timeout or via TsFrameAckDelivery. The attempt counter is incremented only on repeated requests for the same offset — requesting a new offset resets it.

TsFrameGetChunkSticky(sessionId int64, reqOffset uint32, maxChunkSize int, encode func([]byte) []byte) (total uint32, offset uint32, data []byte, taskNonce uint32, isEmpty bool)

---

TsFrameAckDelivery

Acknowledges to the agent that the entire downstream message has been delivered. Releases the downstream session.

TsFrameAckDelivery(sessionId int64, ackOffset uint32, ackNonce uint32)

---

TsFrameTakeStatTasks / TsFrameTakeStatRecv

Atomically take the statistics accumulated by the Frame Manager for a session. Framed transports print "N bytes sent" after TsFrameGetChunk or TsFrameGetChunkSticky, or after a completed TsFramePut, TsFramePutDecoded, or TsFramePutStream.

TsFrameTakeStatTasks(sessionId int64) (StatTasks, int, bool)
TsFrameTakeStatRecv(sessionId int64) (size int, requests int, ok bool)

---

TsFrameResetUpstream / TsFrameResetDownstream

Reset an unfinished upstream or downstream session (e.g., when desync is detected or an agent is explicitly reloaded).

TsFrameResetUpstream(sessionId int64)
TsFrameResetDownstream(sessionId int64)

Used on task/upload cancellation: resetting the downstream session prevents the agent from receiving the canceled task's tail on its next poll.

---

Client GUI Functions

Functions for synchronizing data with GUI clients (File Browser, Process Manager). These functions send results only to the client that initiated the request.

TsClientGuiDisksWindows

Sends the list of Windows drives to the client.

TsClientGuiDisksWindows(taskData adaptix.TaskData, drives []adaptix.ListingDrivesDataWin)

Parameter	Type	Description
taskData	adaptix.TaskData	Task data
drives	[]adaptix.ListingDrivesDataWin	Drive list

---

TsClientGuiFilesWindows

Sends the list of Windows files to the client.

TsClientGuiFilesWindows(taskData adaptix.TaskData, path string, files []adaptix.ListingFileDataWin)

Parameter	Type	Description
taskData	adaptix.TaskData	Task data
path	string	Directory path
files	[]adaptix.ListingFileDataWin	File list

---

TsClientGuiFilesUnix

Sends the list of Unix/Linux files to the client.

TsClientGuiFilesUnix(taskData adaptix.TaskData, path string, files []adaptix.ListingFileDataUnix)

Parameter	Type	Description
taskData	adaptix.TaskData	Task data
path	string	Directory path
files	[]adaptix.ListingFileDataUnix	File list

---

TsClientGuiFilesStatus

Sends the file operation status (delete, rename, etc.) to the client.

TsClientGuiFilesStatus(taskData adaptix.TaskData)

Parameter	Type	Description
taskData	adaptix.TaskData	Task data with MessageType and Message for status

---

TsClientGuiProcessWindows

Sends the list of Windows processes to the client.

TsClientGuiProcessWindows(taskData adaptix.TaskData, process []adaptix.ListingProcessDataWin)

Parameter	Type	Description
taskData	adaptix.TaskData	Task data
process	[]adaptix.ListingProcessDataWin	Process list

---

TsClientGuiProcessUnix

Sends the list of Unix/Linux processes to the client.

TsClientGuiProcessUnix(taskData adaptix.TaskData, process []adaptix.ListingProcessDataUnix)

Parameter	Type	Description
taskData	adaptix.TaskData	Task data
process	[]adaptix.ListingProcessDataUnix	Process list

---

Credentials Functions

TsCredentilsAdd

Adds credentials.

TsCredentilsAdd(creds []map[string]interface{}) error

Credential structure:

map[string]interface{}{
    "username": "admin",
    "password": "hash_or_password",
    "realm":    "DOMAIN",
    "type":     "NTLM",
    "tag":      "DC01",
    "storage":  "LSASS",
    "agent_id": "abc123",
    "host":     "192.168.1.1",
}

Events:

• credentials.add (Pre/Post hooks)

---

TsCredentilsEdit

TsCredentilsEdit(credId int64, username string, password string, realm string, credType string, tag string, storage string, host string) error

Events:

• credentials.edit (Pre/Post hooks)

---

TsCredentialsSetTag

TsCredentialsSetTag(credsId []int64, tag string) error

---

TsCredentilsDelete

TsCredentilsDelete(credsId []int64) error

Events:

• credentials.remove (Pre/Post hooks)

---

Download/Upload Functions

TsDownloadAdd

Initializes a file download. fileId comes from TsFileGenID.

TsDownloadAdd(agentId int64, fileId int64, fileName string, fileSize int64) error

Events:

• download.start (Pre/Post hooks)

---

TsDownloadUpdate

Updates download state.

TsDownloadUpdate(fileId int64, state int, data []byte) error

State	Value	Description
1	RUNNING	Download in progress
2	STOPPED	Paused
3	FINISHED	Completed
4	CANCELED	Cancelled

---

TsDownloadClose

Finishes a download.

TsDownloadClose(fileId int64, reason int) error

Events:

• download.finish (Pre/Post hooks)

---

TsDownloadSave

Saves a file directly (from memory).

TsDownloadSave(agentId int64, fileId int64, filename string, content []byte) error

---

TsDownloadGet

One transfer record. The in-memory map is checked first; otherwise the DB row is returned. Unknown id is "File not found: <id>". No event.

TsDownloadGet(fileId int64) (TransferData, error)

---

TsDownloadGetFilepath

Returns the local path to the downloaded file.

TsDownloadGetFilepath(fileId int64) (string, error)

Returns: Full path to the file on the server.

Note: Works only for completed downloads (state=FINISHED).

---

TsDownloadDelete

Deletes downloaded files.

TsDownloadDelete(fileId []int64) error

Events:

• download.remove (Pre/Post hooks)

---

TsDownloadSetTag

Update of a tag on a group of downloads.

TsDownloadSetTag(fileIds []int64, tag string) error

Parameter	Type	Description
fileIds	[]int64	Array of download FileIds
tag	string	New tag; empty string clears it

---

TsUploadAdd / TsUploadAddContent

Initialize an upload of a file to an agent. TsUploadAdd reads the file from disk (localPath). TsUploadAddContent takes bytes in memory and optional memory-artifact fields. fileId comes from TsFileGenID.

TsUploadAdd(agentId int64, fileId int64, localPath string, remotePath string) error
TsUploadAddContent(agentId int64, fileId int64, remotePath string, content []byte, canceled bool, kind int, artname string, arttype string) error

Parameter	Type	Description
canceled	bool	false → TsUploadClose(CANCELED) rejects with an error; the UI Cancel button is disabled. For artifacts without an agent-side break command. Regular file uploads — true.
kind	int	TRANSFER_KIND_FILE = 0 (regular file) or TRANSFER_KIND_MEMORY = 1 (BOF / shellcode / .NET)
artname	string	Operator-friendly label for Kind=MEMORY (BOF / shellcode name). For FILE — empty string.
arttype	string	Category for Kind=MEMORY ("bof" / "shellcode" / "dotnet"). For FILE — empty string.

Events: upload.start (Pre/Post hooks).

---

TsUploadGetChunk

Returns the next chunk of the upload file. Used by the agent plugin when preparing a portion of data to send to the agent.

TsUploadGetChunk(fileId int64, chunkSize int, needApprove bool) ([]byte, error)

Parameter	Type	Description
fileId	int64	Upload session ID
chunkSize	int	Desired chunk size (bytes)
needApprove	bool	true — Progress is incremented only after TsUploadApprove; false — immediately

Returns: a slice of the read bytes; nil with no error means the file has already been fully sent.

---

TsUploadApprove

Acknowledges delivery of the next chunk of upload data to the agent. Used when needApprove = true, where the agent explicitly confirms receipt of a chunk before Progress is incremented.

TsUploadApprove(fileId int64, approvedBytes int) error

---

TsUploadClose

Closes the upload session (reason — TRANSFER_STATE_FINISHED or TRANSFER_STATE_CANCELED).

TsUploadClose(fileId int64, reason int) error

If reason == TRANSFER_STATE_CANCELED and the upload has Cancellable == false (memory artifact without an agent-side break) — returns upload %d is not cancellable. TsAgentRemove and TsUploadDelete still close that upload. After a successful close, state and progress are saved.

Events: upload.finish (Pre/Post hooks).

---

TsUploadGet

Returns the current snapshot of an upload session. The in-memory map is checked first; otherwise the stored row is returned (finished or canceled). Same shape as TsDownloadGet.

TsUploadGet(fileId int64) (adaptix.TransferData, error)

---

TsUploadDelete

Cancel and remove uploads. Active records are closed as canceled even when Cancellable is false, then the ids are deleted. Clients receive a transfer-delete for each upload. Backs POST /upload/delete.

TsUploadDelete(fileIds []int64) error

---

Listener Functions

TsListenerGet

Returns the data of a running listener.

TsListenerGet(listenerName string) (adaptix.ListenerData, bool)

Parameters:

• listenerName — listener instance name.

Returns: the ListenerData and an existence flag (false — listener not found; an empty name returns false immediately).

---

TsListenerGetProfile

Gets a profile for agent generation.

TsListenerGetProfile(listenerName string) (string, []byte, error)

Returns: watermark, profile bytes, error

---

TsListenerInteralHandler

Handles internal requests (pivot agents).

TsListenerInteralHandler(watermark string, data []byte) (int64, error)

Returns: child agent id (int64) and an error.

---

TsListenerList / TsListenerCatalog

Running listeners, and the listener types registered by extenders.

TsListenerList() (string, error)
TsListenerCatalog() (string, error)

---

Pivot Functions

TsPivotCreate

Creates a pivot connection.

TsPivotCreate(pivotId string, pAgentId int64, chAgentId int64, pivotName string, isRestore bool) error

Events:

• pivot.create (Pre/Post hooks)

---

TsPivotDelete

TsPivotDelete(pivotId string) error

Events:

• pivot.remove (Pre/Post hooks)

---

TsGetPivotInfoByName / TsGetPivotInfoById

TsGetPivotInfoByName(pivotName string) (string, int64, int64)  // pivotId, parentAgentId, childAgentId
TsGetPivotInfoById(pivotId string) (string, int64, int64)      // pivotName, parentAgentId, childAgentId

---

Screenshot Functions

TsScreenshotAdd

Adds a screenshot.

TsScreenshotAdd(agentId int64, Note string, Content []byte) error

Events:

• screenshot.add (Pre/Post hooks)

---

TsScreenshotNote

Updates the note for a screenshot.

TsScreenshotNote(screenId int64, note string) error

---

TsScreenshotDelete

Deletes a screenshot.

TsScreenshotDelete(screenId int64) error

Actions:

1. Deletes the file from disk

2. Removes the record from the DB

3. Synchronizes with clients

Events:

• screenshot.remove (Pre/Post hooks)

---

Target Functions

TsTargetsAdd

Adds new targets (hosts). Duplicates are automatically ignored.

TsTargetsAdd(targets []map[string]interface{}) error

Target structure:

map[string]interface{}{
    "computer": "DC01",           // Computer name
    "domain":   "CORP.LOCAL",     // Domain
    "address":  "192.168.1.10",   // IP address
    "os":       1,                // 1=Windows, 2=Linux, 3=macOS
    "os_desk":  "Windows Server 2019",
    "tag":      "Domain Controller",
    "info":     "Additional information",
    "alive":    true,             // Is target alive
}

Events:

• target.add (Pre/Post hooks)

---

TsTargetsEdit

Edits an existing target.

TsTargetsEdit(targetId int64, computer string, domain string, address string, os int, osDesk string, tag string, info string, alive bool) error

Parameter	Type	Description
targetId	int64	Target ID
computer	string	Computer name
domain	string	Domain
address	string	IP address
os	int	OS type (1/2/3)
osDesk	string	OS description
tag	string	Tag
info	string	Additional info
alive	bool	Is alive

Events:

• target.edit (Pre/Post hooks)

---

TsTargetSetTag

Sets a tag for a group of targets.

TsTargetSetTag(targetsId []int64, tag string) error

---

TsTargetDelete

Deletes targets.

TsTargetDelete(targetsId []int64) error

Events:

• target.remove (Pre/Post hooks)

---

Tunnel Functions

TsTunnelStart

Starts the created tunnel.

TsTunnelStart(TunnelId int64) (int64, error)

Returns: TaskId for tracking

Events:

• tunnel.start (Pre/Post hooks)

---

TsTunnelCreate* Functions

Functions for creating tunnels of different types. Return TunnelId.

TsTunnelCreateSocks4

Creates a SOCKS4 proxy.

TsTunnelCreateSocks4(AgentId int64, Info string, Lhost string, Lport int) (int64, error)

Parameter	Type	Description
AgentId	int64	Agent ID
Info	string	Tunnel description
Lhost	string	Bind address
Lport	int	Bind port

TsTunnelCreateSocks5

Creates a SOCKS5 proxy with optional authentication.

TsTunnelCreateSocks5(AgentId int64, Info string, Lhost string, Lport int, UseAuth bool, Username string, Password string) (int64, error)

Parameter	Type	Description
AgentId	int64	Agent ID
Info	string	Tunnel description
Lhost	string	Bind address
Lport	int	Bind port
UseAuth	bool	Use authentication
Username	string	Username (if UseAuth)
Password	string	Password (if UseAuth)

TsTunnelCreateLportfwd

Creates a local port forward.

TsTunnelCreateLportfwd(AgentId int64, Info string, Lhost string, Lport int, Thost string, Tport int) (int64, error)

Parameter	Type	Description
AgentId	int64	Agent ID
Info	string	Tunnel description
Lhost	string	Local address
Lport	int	Local port
Thost	string	Target address (on agent)
Tport	int	Target port

TsTunnelCreateRportfwd

Creates a reverse port forward.

TsTunnelCreateRportfwd(AgentId int64, Info string, Lport int, Thost string, Tport int) (int64, error)

Parameter	Type	Description
AgentId	int64	Agent ID
Info	string	Tunnel description
Lport	int	Port on agent
Thost	string	Target address (on server)
Tport	int	Target port

---

TsTunnelUpdateRportfwd

Updates reverse port forward status after the agent response.

TsTunnelUpdateRportfwd(tunnelId int, result bool) (string, string, error)

Parameter	Type	Description
tunnelId	int	Tunnel ID (numeric)
result	bool	Whether the tunnel was created on the agent

Returns: TaskId, message, error

---

TsTunnelStop* Functions

Functions for stopping tunnels.

TsTunnelStop

Stops a tunnel by ID.

TsTunnelStop(tunnelId int64) error

Events:

• tunnel.stop (Pre/Post hooks)

TsTunnelStopSocks

Stops a SOCKS proxy by agent and port.

TsTunnelStopSocks(AgentId int64, Port int)

TsTunnelStopLportfwd

Stops a local port forward.

TsTunnelStopLportfwd(AgentId int64, Port int)

TsTunnelStopRportfwd

Stops a reverse port forward. Sends a close command to the agent.

TsTunnelStopRportfwd(AgentId int64, Port int)

---

TsTunnelChannelExists

Checks whether the tunnel channel exists.

TsTunnelChannelExists(channelId int64) bool

---

TsTunnelGetPipe

Gets pipes for reading/writing tunnel data.

TsTunnelGetPipe(AgentId int64, channelId int64) (*io.PipeReader, *io.PipeWriter, error)

Returns: PipeReader for reading data from the server, PipeWriter for writing data to the tunnel.

---

TsTunnelConnection* Functions

Functions for managing tunnel connections.

TsTunnelConnectionData

Sends data to the tunnel channel.

TsTunnelConnectionData(channelId int64, data []byte)

TsTunnelConnectionResume

Resumes the connection after a successful connection on the agent side.

TsTunnelConnectionResume(AgentId int64, channelId int64, ioDirect bool)

Parameter	Type	Description
AgentId	int64	Agent ID
channelId	int64	Channel ID
ioDirect	bool	true = direct transfer without buffering

TsTunnelConnectionClose

Closes the channel connection.

TsTunnelConnectionClose(channelId int64, writeOnly bool)

Parameter	Type	Description
channelId	int64	ChannelId ID
writeOnly	bool	To ensure sufficient time for reading and sending data over a socket. Used in async payloads such as HTTP.

TsTunnelConnectionHalt

Closes the connection with a SOCKS error.

TsTunnelConnectionHalt(channelId int64, errorCode byte)

Parameter	Type	Description
channelId	int64	Channel ID
errorCode	byte	SOCKS5 error code (1-8)

TsTunnelConnectionAccept

Accepts an incoming connection for reverse port forward.

TsTunnelConnectionAccept(tunnelId int64, channelId int64)

---

TsTunnelConnectionBindReply

Reports a SOCKS5 BIND channel phase change to the server (the agent's response to TunnelCallbacks.BindTCP).

TsTunnelConnectionBindReply(channelId int64, phase int, atyp int, addr []byte, port int)

Parameter	Type	Description
channelId	int64	Channel ID
phase	int	TUNNEL_BIND_LISTENING (2) or TUNNEL_BIND_ACCEPTED (3)
atyp	int	address type: ADDRESS_TYPE_IPV4 (1) / DOMAIN (3) / IPV6 (4)
addr	[]byte	bind address (4 / 16 bytes, or domain)
port	int	actual port bound on the agent

---

TsTunnelPause

Pause tunnels connection to client

TsTunnelPause(channelId int)

---

TsTunnelResume

Recume tunnels connection to client

TsTunnelResume(channelId int)

---

Terminal Functions

Functions for managing interactive terminal sessions via the agent.

TsAgentTerminalCloseChannel

Closes the terminal channel and notifies the client.

TsAgentTerminalCloseChannel(terminalId int64, status string) error

Parameter	Type	Description
terminalId	int64	Terminal session ID
status	string	Close status/reason

---

TsTerminalConnExists

Checks whether a terminal connection exists.

TsTerminalConnExists(terminalId int64) bool

Parameter	Type	Description
terminalId	int64	Terminal session ID

Returns: true if the session exists

---

TsTerminalConnResume

Resumes the terminal connection after a successful start on the agent.

TsTerminalConnResume(agentId int64, terminalId int64, ioDirect bool)

Parameter	Type	Description
agentId	int64	Agent ID
terminalId	int64	Terminal session ID
ioDirect	bool	true = direct transfer without buffering

---

TsTerminalConnData

Sends data to the terminal session (output from the agent).

TsTerminalConnData(terminalId int64, data []byte)

Parameter	Type	Description
terminalId	int64	Terminal session ID
data	[]byte	Data to send

---

TsTerminalConnClose

Closes the terminal session.

TsTerminalConnClose(terminalId int64, reason string) error

Parameter	Type	Description
terminalId	int64	Terminal session ID
reason	string	Close reason

---

TsTerminalGetPipe

Gets pipes for terminal input/output.

TsTerminalGetPipe(AgentId int64, terminalId int64) (*io.PipeReader, *io.PipeWriter, error)

Returns: PipeReader for reading input from the client, PipeWriter for writing agent output.

---

Service Functions

TsPluginServiceSendDataAll

Sends data to all clients on behalf of the service.

TsPluginServiceSendDataAll(service string, data string)

---

TsPluginServiceSendDataClient

Sends data to a specific client on behalf of the service.

TsPluginServiceSendDataClient(operator string, service string, data string)

---

AxScript Server Functions

Server-side AxScript engine functions. Allow loading and executing scripts on the server side, defining commands and hooks without client participation.

TsAxScriptLoadUser

Loads a user AxScript on the server.

TsAxScriptLoadUser(name string, script string) error

Parameter	Type	Description
name	string	Script name
script	string	Script content

---

TsAxScriptUnloadUser

Unloads a user AxScript from the server.

TsAxScriptUnloadUser(name string) error

---

TsAxScriptList

Returns a JSON list of loaded scripts.

TsAxScriptList() (string, error)

---

TsAxScriptCommands

Returns a JSON list of registered server-side commands.

TsAxScriptCommands() (string, error)

---

TsAxScriptResolveHooks

Resolves server-side hooks for an agent command. Used when processing commands where the client did not provide a hook/handler.

TsAxScriptResolveHooks(agentName string, agentId int64, listenerRegName string, os int, cmdline string, args map[string]interface{}, client string) (string, string, bool, error)

Parameter	Type	Description
agentName	string	Agent type name
agentId	int64	Agent ID
listenerRegName	string	Registered listener name
os	int	Agent OS type
cmdline	string	Command line
args	map[string]interface{}	Command arguments
client	string	Operator client name

Returns: hookId, handlerId, preHookHandled (true if Pre hook fully handled the command), error

---

TsAxScriptParseAndExecute

Parses and executes a raw command via the server-side AxScript engine.

TsAxScriptParseAndExecute(agentId int64, username string, cmdline string) error

TsAxScriptParseAndExecuteResult(agentId int64, username string, cmdline string) (taskId int64, local bool, err error)

Parameter	Type	Description
agentId	int64	Agent ID
username	string	Operator name
cmdline	string	Command line

---

TsAxScriptIsServerHook

True when id is a hook registered by a teamserver script rather than a client script.

AxGetAgentContext(id string) bool

---

Event Hook Functions

Generic event-hook registration. Unlike the narrow TsEventHookOnPost / TsEventHookOnPre wrappers, these methods take explicit phase and priority — multiple hooks on one event are ordered by priority.

TsEventHookRegister

Registers an event hook with an explicit phase and priority.

TsEventHookRegister(eventType string, name string, phase int, priority int, handler func(event any) error) string

Parameters:

Parameter	Type	Description
eventType	string	Event type (e.g. "task.create", "agent.new", "upload.finish")
name	string	Hook name (used for bulk unregister via TsEventHookUnregisterByName).
phase	int	0 — synchronous, before the action; 1 — asynchronous, after the action.
priority	int	Priority within the phase. Calls run in priority order
handler	func(event any) error	Handler function; receives the event as any (type-asserted by the plugin).

Returns: the hook ID (string).

---

TsEventHookOnPre / TsEventHookOnPost

Registers a pre or post hook at the default priority and returns the hook id. Neither call emits an event.

TsEventHookOnPre(eventType string, name string, handler func(event any) error) string
TsEventHookOnPost(eventType string, name string, handler func(event any) error) string

---

TsEventHookUnregister

Unregisters one hook by the id returned from TsEventHookRegister.

TsEventHookUnregister(hookID string) bool

Returns true when a hook with that id was removed.

---

TsEventHookUnregisterByName

Unregisters all hooks registered under the given name.

TsEventHookUnregisterByName(name string) int

Returns: the number of hooks removed (0 if none found).

---

TsEventHookSetEnabled

Enables/disables a registered hook without unregistering it.

TsEventHookSetEnabled(hookID string, enabled bool) error

---

Extender Data Functions

Functions for storing extender data in the database.

TsExtenderDataSave

Saves extender data to the database.

TsExtenderDataSave(extenderName string, key string, value []byte) error

---

TsExtenderDataLoad

Loads extender data from the database.

TsExtenderDataLoad(extenderName string, key string) ([]byte, error)

---

TsExtenderDataDelete

Deletes data by key from the database.

TsExtenderDataDelete(extenderName string, key string) error

---

TsExtenderDataKeys

Returns a list of saved extender keys.

TsExtenderDataKeys(extenderName string) ([]string, error)

---

TsExtenderDataDeleteAll

Deletes all extender data from the database.

TsExtenderDataDeleteAll(extenderName string) error

---

Endpoint Functions

Functions for registering HTTP endpoints.

TsEndpointRegister

Registers a protected endpoint (uses the teamserver's shared JWT authentication).

TsEndpointRegister(method string, path string, handler func(username string, body []byte) (int, []byte)) error

Parameter	Type	Description
method	string	HTTP method (GET, POST...)
path	string	Endpoint path
handler	func(username string, body []byte) (int, []byte)	Handler

Handler parameters:

• username — authenticated username

• body — request body

Handler returns:

• int — HTTP status code

• []byte — response body

---

TsEndpointUnregister

Unregisters an endpoint.

TsEndpointUnregister(method string, path string) error

---

TsEndpointExists

Checks whether an endpoint exists.

TsEndpointExists(method string, path string) bool

---

TsEndpointRegisterPublic

Registers a public endpoint (no authentication).

TsEndpointRegisterPublic(method string, path string, handler func(body []byte) (int, []byte)) error

Parameter	Type	Description
method	string	HTTP method (GET, POST...)
path	string	Endpoint path
handler	func(body []byte) (int, []byte)	Handler

---

TsEndpointUnregisterPublic

Unregisters a public endpoint.

TsEndpointUnregisterPublic(method string, path string) error

---

TsEndpointExistsPublic

Checks whether a public endpoint exists.

TsEndpointExistsPublic(method string, path string) bool

---

Logging Functions

Functions for emitting entries to the centralized LogManager. Entries are kept in a 5000-element RAM ring buffer (oldest are evicted), printed to stdout (status Debug only if the server runs with --debug), and batch-broadcast to every subscribed client every 50 ms / 100 entries via the WebSocket.

The Source field is conventionally prefixed by owner type so the client can filter by source:

Prefix	Owner
server:<file>	built-in server code
listener:<name>	listener plugins
agent:<id>	per-agent activity
axscript:<file>	user-supplied AxScript
service:<name>	service plugins

Level is the nesting depth (0 = top-level); the client renders deeper levels with extra indentation.

TsLogAdd

Emits one entry to the LogManager.

TsLogAdd(status adaptix.LogStatus, level int, source, category string, format string, args ...any)

Parameter	Type	Description
status	adaptix.LogStatus	LogStatusDebug(0) / LogStatusInfo(1) / LogStatusSuccess(2) / LogStatusWarn(3) / LogStatusError(4)
level	int	Nesting depth
source	string	Source. If category is empty and source contains :, the part before the first colon becomes the source and the rest becomes the category
category	string	Category. Empty lets the manager split it out of source
format	string	fmt.Sprintf format
args	...any	Format arguments

---

TsLogWriter

Returns an io.Writer adapter that marshals each line written to it as a separate LogEntry.

TsLogWriter(status adaptix.LogStatus, source, category string) io.Writer

Parameter	Type	Description
status	adaptix.LogStatus	Severity for every entry
source	string	Source tag for every entry
category	string	Category for every entry. Empty is allowed

Typical use inside a listener plugin:

import (
    "log"
    adaptix "github.com/Adaptix-Framework/axc2/v2"
)

server := &http.Server{
    Addr:     fmt.Sprintf("%s:%d", t.Config.HostBind, t.Config.PortBind),
    Handler:  router,
    ErrorLog: log.New(Ts.TsLogWriter(adaptix.LogStatusWarn, logSrc, ""), "", 0),
}

---

Payload Functions

The payload store — generated agent artifacts (Payloads table, content on the server disk).

TsPayloadRegister

TsPayloadRegister(agentType, filename string, content []byte, listeners []string, configJson, creator, buildId, watermark, description string) (adaptix.PayloadData, error)

Stores a payload: metadata row in the DB + content on disk (with SHA1/SHA256/MD5).

---

TsPayloadRemove

Remove payload from payload storage.

TsPayloadRemove(ids []int64, hard bool) error

---

---

Utility Functions

TsConvertCpToUTF8

Converts a string from a code page to UTF-8.

TsConvertCpToUTF8(input string, codePage int) string

Supported code pages:

• 866 (Russian DOS)

• 1251 (Cyrillic Windows)

• 1252 (Western European Windows)

• 936 (Chinese GBK)

• 65001 (UTF-8)

• and many others...

---

TsConvertUTF8toCp

Converts UTF-8 to the agent's code page.

TsConvertUTF8toCp(input string, codePage int) string

---

TsWin32Error

Returns a description of a Windows error code.

TsWin32Error(errorCode uint) string

---

Data Types

adaptix.AgentData

type AgentData struct {
    Crc          string   // CRC/watermark of the agent type
    Id           int64    // Unique agent identifier
    UID          []byte   // Optional plugin-defined identifier
    Name         string   // Agent type name
    SessionKey   []byte   // Session key for encryption
    Listener     string   // Listener name
    Async        bool     // Asynchronous mode
    ExternalIP   string   // External IP address
    InternalIP   string   // Internal IP address
    GmtOffset    int      // Timezone offset
    Sleep        uint     // Sleep interval (seconds)
    Jitter       uint     // Jitter (percent)
    Pid          string   // Process PID
    Tid          string   // Thread TID
    Arch         string   // Architecture (x86, x64)
    Elevated     bool     // Elevated privileges
    Process      string   // Process name
    Os           int      // OS type (0=Windows, 1=Linux, 2=macOS)
    OsDesc       string   // OS description
    Domain       string   // Domain
    Computer     string   // Computer name
    Username     string   // User name
    Impersonated string   // Impersonated user
    OemCP        int      // OEM code page
    ACP          int      // ANSI code page
    CreateTime   int64    // Creation time (Unix timestamp)
    LastTick     int      // Last response time
    KillDate     int      // Self-destruct date
    WorkingTime  int      // Working time
    Tags         string   // Tags
    Mark         string   // Mark (Inactive, Terminated, etc.)
    Color        string   // Color in the GUI
    TargetId     int64    // Associated target ID (0 = none)
    CustomData   []byte   // Arbitrary plugin data
}

---

adaptix.TaskData

type TaskData struct {
    Type        int      // Type: TASK_TYPE_TASK=1, TASK_TYPE_BROWSER=2, TASK_TYPE_JOB=3, TASK_TYPE_TUNNEL=4, TASK_TYPE_PROXY_DATA=5
    TaskId      int64    // Unique task ID
    AgentId     int64    // Agent ID
    Client      string   // Client (operator) name
    HookId      string   // Hook ID for callback
    HandlerId   string   // Handler ID for callback
    User        string   // User on the target machine
    Computer    string   // Computer name
    StartDate   int64    // Start time
    FinishDate  int64    // Finish time
    Data        []byte   // Binary task data
    CommandLine string   // Command line
    MessageType int      // Message type: INFO=5, ERROR=6, SUCCESS=7
    Message     string   // Message header
    ClearText   string   // Message text
    Completed   bool     // Completion flag
    Priority    uint     // Priority of the task in HostedQueue (higher = earlier)
    Sync        bool     // Sync to the GUI

    // OnDispatch runs after the task is taken from HostedQueue and before PackTasks. Not serialized — lost on server restart.
    OnDispatch     func(ts any, task *TaskData) `json:"-" msgpack:"-"`

    // OnComplete fires once when Completed becomes true: on the agent result (TsTaskUpdate) or immediately when OnDispatch itself sets Completed.
    OnComplete     func(ts any, task *TaskData) `json:"-" msgpack:"-"`

    // Repeat puts the task back on HostedQueue after a dispatch while Completed is false.
    Repeat         bool                         `json:"-" msgpack:"-"`

    // DispatchBudget is how many bytes OnDispatch may still put in task.Data for this poll. 0 means unknown.
    DispatchBudget int                          `json:"-" msgpack:"-"`
}

---

adaptix.ListenerData

type ListenerData struct {
    Name       string   // Unique listener name
    RegName    string   // Registered type
    Protocol   string   // Protocol
    Type       string   // Listener type
    BindHost   string   // Bind address
    BindPort   string   // Bind port
    AgentAddr  string   // Address used by the agent
    CreateTime int64    // Creation time
    Status     string   // Status (running, stopped, paused)
    Data       string   // Additional data (JSON)
    Watermark  string   // Watermark
}

---

adaptix.TransferData

type TransferData struct {
    FileId     int64    // Unique file ID
    AgentId    int64    // Agent ID
    AgentName  string   // Agent type name
    User       string   // User
    Computer   string   // Computer
    RemotePath string   // Path on the target machine
    LocalPath  string   // Local path on the server
    TotalSize  int64    // Total file size
    Progress   int64    // How much has been transferred (downloads: received, uploads: sent)
    ReadOffset int64    // (uploads only) Read offset, not serialized
    Date       int64    // Start date
    State      int      // State: RUNNING=1, STOPPED=2, FINISHED=3, CANCELED=4
    Tag        string   // Arbitrary tag (set via TsDownloadSetTag)
}

---

adaptix.TunnelData

type TunnelData struct {
    TunnelId  int64    // Unique tunnel ID
    AgentId   int64    // Agent ID
    Computer  string   // Computer
    Username  string   // User
    Process   string   // Process
    Type      string   // Type (socks4, socks5, lportfwd, rportfwd)
    Info      string   // Additional information
    Interface string   // Bind interface
    Port      string   // Port
    Client    string   // Client that created the tunnel
    Fhost     string   // Forward host
    Fport     string   // Forward port
    AuthUser  string   // Authentication user
    AuthPass  string   // Authentication password
}

---

adaptix.PivotData

type PivotData struct {
    PivotId       string   // Unique pivot ID (remains a string)
    PivotName     string   // Pivot name
    ParentAgentId int64    // Parent agent ID
    ChildAgentId  int64    // Child agent ID
}

---

adaptix.CredsData

type CredsData struct {
    CredId   int64    // Unique ID
    Username string   // User name
    Password string   // Password or hash
    Realm    string   // Domain/realm
    Type     string   // Type (NTLM, Plaintext, Kerberos)
    Tag      string   // Tag
    Date     int64    // Add date
    Storage  string   // Source (LSASS, SAM, DCSync)
    AgentId  int64    // Source agent ID
    Host     string   // Source host
}

---

adaptix.TargetData

type TargetData struct {
    TargetId int64     // Unique target ID
    Computer string    // Computer name
    Domain   string    // Domain
    Address  string    // IP address
    Os       int       // OS type
    OsDesk   string    // OS description
    Tag      string    // Tag
    Info     string    // Additional information
    Date     int64     // Add date
    Alive    bool      // Alive
    Agents   []int64   // List of agent IDs
}

---

adaptix.ScreenData

type ScreenData struct {
    ScreenId  int64    // Unique screenshot ID
    User      string   // User
    Computer  string   // Computer
    LocalPath string   // Local path on the server
    Note      string   // Note
    Date      int64    // Date
    Content   []byte   // Binary content (for writes; not serialized in listings)
}

---

adaptix.StatTasks / adaptix.TaskStat

Agent task statistics (returned by TsAgentGetHostedAll, TsAgentGetHostedTasks, and TsFrameTakeStatTasks).

type TaskStat struct {
    Count int `json:"count"` // number of tasks
    Bytes int `json:"bytes"` // total size
}

type StatTasks struct {
    Local   TaskStat `json:"local"`   // local (non-agent) tasks
    Task    TaskStat `json:"task"`    // regular commands
    Browser TaskStat `json:"browser"` // browser tasks
    Job     TaskStat `json:"job"`     // job tasks
    Tunnel  TaskStat `json:"tunnel"`  // tunnel tasks
    Proxy   TaskStat `json:"proxy"`   // proxy data
    Other   TaskStat `json:"other"`   // other types
    Packed  int      `json:"packed"`  // final packed block size
}

Helpers: stat.Of(taskType) — the stat for a task type; stat.Commands() — Task+Job; stat.Total() — sum of all categories; stat.Empty(); stat.SizeString() — human-readable size (FormatByteSize).

---

axc2 helpers (command arguments and notes)

The github.com/Adaptix-Framework/axc2/v2 package provides helpers for parsing args map[string]any inside CreateCommand and ready-made console notes.

CoerceFloat64(v any) (float64, bool)

GetStringArg(args, key) (string, error)         GetStringArgDefault(args, key, def) string
GetIntArg(args, key) (int, error)               GetFloatArg(args, key) (float64, error)
GetFloatArgDefault(args, key, def) float64      GetBoolArg(args, key) bool
GetFileArg(args, key) ([]byte, error)

MakeProxyTask(packData []byte, priority uint) TaskData
FormatByteSize(n int) string
FormatTransferNote(received bool, nBytes, nRequests int) string
QuietFrameRecv(nBytes, nRequests int) bool
NoteFrameSent(ts, agentId) / NoteFrameRecv(ts, agentId)   // see Frame Manager

---

Constants

// Task types
const (
    TASK_TYPE_TASK    = 1   // Regular task
    TASK_TYPE_BROWSER = 2   // File/Process Browser
    TASK_TYPE_JOB     = 3   // Background job
    TASK_TYPE_TUNNEL  = 4   // Tunnel
)

// Console message types
const (
    CONSOLE_OUT_LOCAL         = 1
    CONSOLE_OUT_LOCAL_INFO    = 2
    CONSOLE_OUT_LOCAL_ERROR   = 3
    CONSOLE_OUT_LOCAL_SUCCESS = 4
    CONSOLE_OUT_INFO          = 5   // INFO
    CONSOLE_OUT_ERROR         = 6   // ERROR
    CONSOLE_OUT_SUCCESS       = 7   // SUCCESS
    CONSOLE_OUT               = 10
)

// Transfer states
const (
    TRANSFER_STATE_RUNNING  = 1
    TRANSFER_STATE_STOPPED  = 2
    TRANSFER_STATE_FINISHED = 3
    TRANSFER_STATE_CANCELED = 4
)

// Transfer direction (used in TYPE_TRANSFER_* sync packets)
const (
    TRANSFER_DOWNLOAD = 1
    TRANSFER_UPLOAD   = 2
)