Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.signalrooms.xyz/llms.txt

Use this file to discover all available pages before exploring further.

​
Logs and evidence

Status: Current reference for log subscription and minimal evidence export. Richer post-run evidence bundle structure is In progress. Two evidence surfaces, two use cases:
  • Logs: server-pushed log.line notifications you subscribe to for real-time visibility into a running thread.
  • Evidence bundles: immutable artifacts you export at the end of a run, used for post-run review or to attach to a support ticket.
Both are operational. Neither makes claims about TikTok-side outcomes; both record what Warmr’s runner observed and did.

​
Logs: real-time visibility

​
How the stream works

The control plane uses JSON-RPC notifications:
  • Subscribe: logs.subscribe (optionally with configurationId and/or accountUsername filters).
  • Each log line is delivered as a log.line notification.
  • Unsubscribe: logs.unsubscribe, or close the connection.
The warmrctl logs command wraps this:
CommandWhat it does
warmrctl logsSubscribes, prints the subscription confirmation, then unsubscribes. Useful to confirm the channel works.
warmrctl logs --followStays subscribed and streams notifications until Ctrl-C.
warmrctl logs --follow --configuration-id <ID>Streams notifications only for one configuration. Server-side filter, cheap.
warmrctl logs --follow --account-username <USER>Streams only lines tagged with one TikTok username.
warmrctl --json logs --followStreams as JSON-RPC frames (one per line) for agent parsing.
You can combine --configuration-id and --account-username to narrow further.

​
log.line payload

{
  "method": "log.line",
  "params": {
    "subscriptionId": "sub-019e2211-...",
    "timestamp": "2026-05-13T15:42:32Z",
    "configurationName": "Lane 2 morning",
    "accountUsername": "@example",
    "severity": "INFO",
    "message": "thread complete: 5/5 accounts processed"
  }
}
FieldNotes
subscriptionIdEchoes the subscription, so multiplexed agents can route lines.
timestampISO 8601 in UTC.
configurationNameHuman name from the thread configuration.
accountUsernameThe TikTok account this line was emitted under, when applicable.
severityINFO, WARNING, or ERROR.
messageFree-form text, readable, not stable schema.
Full reference: Log events.

​
What appears in a log stream

Typical run, narrated by the log stream: 
INFO  thread starting (configurationId=9f3a-..., accounts=5, devices=1)
INFO  device lane attached (udid=...)
INFO  account switch begin (target=@user1)
INFO  account switch complete
INFO  workflow started (mode=warmup, type=feed)
INFO  feed video watched (durationSec=8.3, liked=false)
INFO  feed video watched (durationSec=5.1, liked=true)
INFO  feed video watched (durationSec=11.7, liked=false)
INFO  account complete (videosWatched=8, likesGiven=2)
INFO  pause between accounts (durationSec=10)
INFO  account switch begin (target=@user2)
...
INFO  thread complete: 5/5 accounts processed
An erroring run interleaves WARNING / ERROR lines with surrounding context, that’s how you tell whether an error is fatal (followed by the thread stopping) or transient (followed by a retry).

​
Practical patterns

Watch one run, narrate it to terminal: 
warmrctl logs --follow --configuration-id <CONFIGURATION_UUID>
Watch one account across whatever runs touch it: 
warmrctl logs --follow --account-username "@example"
Grab the last 60 seconds of logs after a failure (no time-range filter natively, you re-subscribe and wait): 
warmrctl --json logs --follow --configuration-id <CONFIGURATION_UUID> \
  | jq -c 'select(.params.severity == "WARNING" or .params.severity == "ERROR")'
Multiplex multiple runs to one terminal: 
# No filter, get everything. Only sane on small hosts.
warmrctl --json logs --follow | jq -c '.params | {time: .timestamp, cfg: .configurationName, sev: .severity, msg: .message}'

​
Evidence bundles: post-run audit

​
Exporting an evidence bundle

warmrctl evidence export
warmrctl --json evidence export
The command writes an evidence bundle to disk. The response includes the bundle’s path. The bundle is a snapshot of:
  • Job summaries (one entry per thread that ran).
  • The associated logs.
  • App state at the moment of export.
Each export creates a separate bundle, older exports aren’t superseded. Treat it like committing a git tag: once exported, the bundle is immutable from the agent’s perspective.

​
What’s in a bundle today

Current (minimal):
  • Thread summary fields: id, configurationId, configurationName, accountUsername, deviceUDID, deviceName, status, startedAt, finishedAt, elapsedSeconds, videosWatched, likesGiven, favoritesGiven, errorMessage.
  • Log lines tied to the thread.
  • App build info at time of export.

​
What’s planned

In progress:
  • Link logs to run history entries (so a single bundle includes the full action history and not just summaries).
  • Evidence entries for approval gates (which actions were approved, when, by whom, with what parameters).
  • Failure-class tagging on the error lines that triggered a run stop.
  • Lane + account state snapshots at run boundaries.
Planned:
  • Evidence bundles that include a stop reason (operator-requested, error class, recovery exhausted, etc.).
  • A evidence index per host so you can navigate “every run from Monday afternoon” without grepping files.

​
Where bundles live on disk

The export response prints the path. Currently bundles live under Warmr’s application support directory. Don’t expect a stable on-disk path between versions, read it from the response. If you need to ship a bundle to support, the response path is what you tar and attach.

​
Treating evidence honestly

Logs and evidence record what Warmr’s runner observed and did. They are not:
  • Proof of TikTok-side success. A clean evidence export does not prove a video reached the For You feed, an account stayed in good standing, or a publication is visible to followers. It proves the in-app publish flow finished without an error from Warmr’s perspective.
  • A bypass for platform policy. If a thread fails because TikTok showed a captcha or rate-limited the account, the evidence bundle records that, it doesn’t work around it.
  • Marketing material. Per Claims and safety, don’t paste evidence stats into copy that implies platform-outcome guarantees.
What they are:
  • The “what did it do?” answer for any run.
  • The forensic trail when an account changes state and you want to know whether Warmr was involved.
  • Support material that lets the SignalRoom team reproduce or explain a problem.