Tasker

Control another instance by IP: Remote Tasker. The node selector chooses Local or a saved remote connection; + New connection… accepts a connection code. Task settings and commands apply to the selected node. Native editor and terminal actions remain local. The Output and Traffic descriptions below refer to Local; remote output uses explicit Refresh (↺) / Older / Observe controls, and Traffic is local-only.

Tasker is the /tasker.html page that stores schedules and runs local tasks.

List

Tasks are read from the schedules table. The list shows the name, the state and the main run parameters.

Within each group, running tasks and enabled schedules that are neither paused nor deferred come first. The remaining tasks follow; each category is sorted alphabetically by name. Running tasks stay in the first category even if their schedule is disabled.

BrowserAutomationStudio XML projects use the separate BAS page (Beta), not the ZennoPoster xml executor below.

Set dot-separated name grouping in Config → Interface → Tasker grouping depth. Changes save automatically: 0 gives a flat list, 1 is the default single level, 2 gives two levels, and so on. For example, Project.Accounts.Register at depth 2 appears under Project → Accounts. Groups require at least two tasks. Each level collapses independently; parent counts include nested tasks. This interface setting applies to both Local and remote nodes when opening Tasker.

Editing

A task is defined by:

  • a name;
  • an executor;
  • a path to a script, file or task;
  • arguments;
  • the enabled state;
  • a schedule;
  • an overlap policy;
  • a payload.

Supported executors:

Executor What it runs
python, node, ts-node, npm scripts of the matching runtimes
exe, cmd, bat, bash, ps1 executables and shell scripts
csx a C# script; the task list carries a compile-check button for it
xml a ZennoPoster template: the built-in runtime plays the XML graph, and the browser is chosen on the task card

Use Ctrl+click to select several tasks and Shift+click to select a range. Changed fields from the Settings and Schedule tabs are saved to every selected task, while names remain individual. The Delete key removes the selected task or the whole selection after confirmation.

Resources

RAM and CPU appear per task and in the header total. On Windows, each instance includes its child processes, including browsers. CPU is shown as a share of the whole machine after the second sample. Cronopus's own memory is separate; in-process XML runs are marked instead of receiving an individual memory figure. Each active instance shows the memory of its entire process tree and its process count. Instance figures, task totals and header RAM use one snapshot; a task's memory equals the sum of its instances.

Schedule

The UI can build:

  • on-demand runs;
  • daily runs;
  • runs on days of the week;
  • runs on a day of the month;
  • an interval in minutes.

The result is stored in cron, interval_minutes and fixed_time.

Overlap

  • skip — do not start a new instance while one is active;
  • parallel — allow several instances up to max_threads;
  • kill_restart — stop the active instances and start a new one.

Account for a template run

The xml executor reserves an account only when the template actually works with one: the acc0 variable is declared in the <Variables> block and mentioned somewhere else — in a step or in the own code. A declaration alone is not enough: ZennoPoster templates carry variables over from a donor project in bulk, and many of them are never read.

Reservation also kicks in when the task payload explicitly sets accountTable or condition. It is skipped when the payload already carries a non-empty acc0 — the account was picked by hand.

The table comes from payload.accountTable, otherwise it is __<task name up to the first dot>. The condition is payload.condition (the substring NOW is replaced with the current UTC time), 1=1 by default.

A taken account gets status = 'busy', and its columns plus the rows from instance and folder_profile go into the project variables and into the run payload — that is where the xml branch reads the proxy and the browser profile from, so account data overrides the task settings.

The release happens in finally: idle on success, fail on any other exit, including a kill by the runtime limit. A failure of the release itself is logged as a warning and never breaks the run.

Special cases:

  • the account table does not exist — a configuration error: status error, last_exit = -1;
  • no free account matches the condition — the run did not happen: last_exit stays empty and the runs_total / runs_success counters are left alone.

Max runtime

The Max runtime field in the task settings (column timeout_seconds). 0 means no limit.

Once the limit passes, the run is aborted, a line about the limit goes into the output, and the run counts as a failure (last_exit = -1).

How the abort happens depends on the executor:

  • an external process (python, node, cmd, npm, …) is killed together with its process tree — a real stop;
  • xml gets its CancellationToken cancelled. Cancellation is cooperative: it checks the token between branches, and code that never looks at the token will not stop.

Control

Available actions:

  • Run;
  • Stop;
  • Restart;
  • enable or disable the schedule;
  • delete and duplicate;
  • open the file or its folder;
  • open a terminal;
  • check and install Python and Node dependencies.

Run, schedule pause/enable, Resume schedule, Restart, Interrupt and Eliminate apply to all selected tasks. Run queues the chosen count for each task; the header shows the selection count. Bulk controls continue after individual failures and collect errors into one message. Interrupt can also clear pending runs.

POST /tasker/run accepts optional non-empty args for that manual batch. They replace saved arguments in the queued runs without changing the task; payload flags are still added. See Task API.

Attempt counters

Reset attempts clears the successful and failed attempt counters for all selected tasks. It does not stop running instances or change their schedules.

Upload a local task

Select a local task and press ↑ Upload, choose a saved Remote Tasker server and its destination folder, then confirm. This copies the task's script file or folder, current settings, schedule and payload, and creates a task on the server. The script path is changed to the destination; run counters start at zero. An enabled schedule remains enabled and can start on the server immediately. File replacement requires confirmation. If task creation is unconfirmed after a connection failure, inspect the server's tasks before starting a new upload; Resume checks the same operation. See Remote Tasker.

Local output

Output of the active run is streamed over SSE. Parallel instances each get their own runId.

Select a thread chip to show only its lines. The selection survives subscription refreshes and incoming buffer clears for the same task, including progress-line replacements. Selecting another task resets the filter. Auto-scroll follows new output and remembers the setting. When disabled, the displayed log is frozen, including progress replacements and clear events. Enabling it again applies the bounded buffer of incoming output and scrolls to the end.

Execution

The tab shows the launch command built from the task's saved settings and payload. Passwords are masked. Saving or clearing the payload refreshes the command. Late statistics, instance and queue responses cannot replace the current task's data after switching cards.

Traffic

A task tab with traffic from trafficLog.jsonl: GET /traffic?tail=N&task_id=..., polled every 3 seconds. ZpRuntime writes it; details are in Traffic. The file rotates itself.

Payload

A payload consists of a schema and values. It can be edited, imported, exported and passed to the executor on start.

Changing the script path regenerates payload fields and defaults from the new Python script. From script replaces the payload using the current script path, including an unsaved edit. Outdated parameter responses are ignored. When the path is changed, payload Save keeps edits in the draft until Settings saves the new path and payload together. Otherwise, Save and Clear persist the payload independently of unsaved Settings. Successful responses update the task card immediately; a failed save keeps the modal open. Multiselect fields preserve all selected values. Confirmation dialogs appear above the payload modal, and dragging from the modal to the backdrop does not close it.

Fields support type, title, argument flag, position, default value and enum; drag them to change their order. A command preview shows how values become arguments. Python argparse and click parameters can populate the schema by parsing the script without running it.

Skip empty omits an empty value so the script uses its default. Otherwise the empty value is passed explicitly. Password fields are masked in the preview and the run log's [launch] line. Invalid argument conversion stops the run at step=payload.

API

Control from a running script without looking up an ID: Task API. Deferring the next run, pausing and resuming the schedule are available.

External agents use MCP. For dashboard HTTP integrations, see Task API#Driving the application from outside for request bodies, string field types, revisions, responses and the create/copy sequence for settings and payload.

Main routes:

  • GET /tasker/list
  • POST /tasker/save
  • POST /tasker/delete
  • POST /tasker/run
  • POST /tasker/stop
  • GET /tasker/instances
  • POST /tasker/kill-instance
  • GET|POST /tasker/payload
  • POST /tasker/args-preview
  • GET /tasker/output/stream
  • GET /tasker/queue
  • POST /tasker/clear-queue