No-code automation

A flow has a name, an ordered list of steps, its own variables and the profiles it targets. All of that belongs to the flow itself, and the selection survives a restart.

Flows live on your computer, in the app data folder, and on macOS and Linux they are readable by your account and nobody else. Steps often carry a login or a form value.

Nineteen kinds of step exist today: thirteen everyday ones and six for the harder work. The six are branching, list iteration, tabs, cookies, your own JavaScript and network waits.

There is no recorder. You add each step from a form: choose the kind, fill the fields it needs, save.

While you edit, the Flows screen looks for the silent breakages that otherwise show up mid run on a live account. A click with no target, a wait with neither a time nor an element, an extract with nowhere to put the result.

Every remark names the step number, and you can tell an error from a warning at a glance. You can still save, because an unfinished flow is a normal working state.

Any text field of a step can carry {{name}}. At run time each profile puts its own value there, and an unknown name comes out as an empty string rather than an error.

Every profile takes its values from three layers: the flow's default values, the built-in profile fields, then the per-profile values you typed under the target chips. That is how one flow signs into twenty accounts without twenty copies of itself.

You can write a variable name in any script, in all 22 languages the app ships in. Text read off a page fills a variable too, up to 4000 characters, and in the step log the input step shows dots in place of a value that came from one.

• profile.name

  The profile's name, as it appears in your list.

• profile.id

  The profile's ID, the same one the local API names.

• profile.group

  The group the profile belongs to.

• profile.totp

  A one-time code from the profile's own secret, computed at the moment of substitution rather than when the run starts.

• now

  The date and time with the time zone of this computer, taken at the moment of substitution.

Repeat runs its body from 1 to 1000 passes. What counts towards progress is the steps themselves rather than the wrapper around them, so the bar shows real work.

A branch tests the page or a variable and only the winning side runs. Nobody can know in advance which side wins, so the progress bar counts those steps in as it goes and lands on the end instead of stalling short.

For each takes a selector and a cap, ten by default, and re-queries the list on every pass. Outside a loop the current-element reference deliberately matches nothing, because quietly falling back to the whole page would click something you never chose.

Concurrency is 1, 2, 3, 5 or 8. You never get more profiles open at once than the Browsers at once setting on the Engine screen allows: that number is read off this machine's memory, and you can set your own.

A profile that meets the limit waits for a free slot instead of going down as failed. It waits up to thirty minutes, trying every five seconds, and only then do you see a failure.

You can walk away to another flow: the run keeps going and a banner with Stop follows you. Press it in the middle of a loop and the current step finishes before everything stops, rather than being killed mid action.

You see a failed step in the log with its error, and the profile's failure count goes up. What the profile does next is the flow's rule, and a line just above Run flow names it for the open flow: a new flow stops that profile at the failed step while the other profiles go on. A flow made in an earlier version of ARMANOS keeps working as it did, and the profile takes the next step.

Done means the written steps ran. If any step of a profile failed, that profile is marked failed and says how many, and the run itself is failed rather than green.

A long run does not blur that count: the log keeps only its last lines, and failures are counted apart from it. Familiar errors reach you in your own language, and anything else is shown exactly as it came back.

Debug from here on a step runs the flow on one profile from that step, with Pause, One step and Continue. A failed step stops a debug run; fix it and Continue from here goes on in the same open page with the same variables.

Undo and Redo above the steps take back any change to the flow, up to 100 steps, with Cmd or Ctrl+Z as usual. The choice of profiles is not undone.

ARMANOS Browser is a separate Chromium process, so a flow drives it over the debugging channel on loopback. A flow drives the built-in engine through its own window instead, but you write a step once: which engine is underneath does not change it.

Of that protocol ARMANOS does not switch on Runtime.enable, a domain whose hooks page code can observe. A flow has no use for it: it asks whether the page is ready rather than subscribing to events.

A schedule belongs to a flow and names the profiles, the time and how many run at once, up to five. Daily at a time, weekly on chosen days, or every N hours.

Times are local, so after a clock change nine in the morning is still nine in the morning. You see how many runs were missed, and none of them are replayed in a burst.

A schedule fires only while ARMANOS is open, and the window says so plainly. A profile you have open right now is left alone.

1. 1

   Pick the flow

   Open the clock button on its row in the flow list.

2. 2

   Pick when

   Daily, weekly on chosen days, or every N hours, in your local time.

3. 3

   Pick who

   Tick the profiles, then choose how many run at once.

4. 4

   Read the outcome

   The row shows the last run, its result, and how many runs were missed.