aty


aty is a Node.js package that allows for automatic typing of strings into programs on Mac.

Installation

aty can be either installed globally, or as a library.

Demo

The demo below shows how one can use aty to automatically type a program which they just wrote.

Programming like a hacker with aty

Table Of Contents

- Installation
- Demo
* Programming like a hacker with aty
- Table Of Contents
- API
* [e(lines: string[])](#elines-string-void)
* w()
* aty(code: string): string
* activateApp(name: string): string
* type(string: string, delayFrom?: number = 50, delayTo?: number = 100, noIndent?: boolean = false): string
* typeInstant(string: string): string
* delay(time: number): string
* [keystroke(word: string, commands?: string[]): string](#keystrokeword-stringcommands-string-string)
* [code(code: string, commands?: string[]): string](#codecode-stringcommands-string-string)
- API Examples
* Register Domain For Package: mnp-expensive
- Key Code Reference Table
- CLI
* Accepted Arguments
-t, --text
-a, --app
* -i, --instant
* -d, --minDelay
* -m, --maxDelay
* -h, --help
* -v, --version
- CLI Examples
* aty "echo test\n" -i date -d 100 -a Terminal
- Copyright

API

The package is available by importing:

- its default function aty for generating an Apple Script code to be executed;
- the exec command to execute it;
- the e function which is a combination of aty and exec;
- the w function to pause execution of the script and wait for user input;
- various tagged templates to compose code for the script (e.g., such as type, activateApplication, delay, code, _etc_).

`js
import aty, {
exec, e, w, activateApp, type, typeInstant, delay, keystroke, code,
} from 'aty'
`

`js
/ yarn example /
import aty, { exec, type, typeInstant, activateApp } from 'aty'

const s = Hello World! \\
This is a new application that can type strings.

;(async () => {
const a = aty
${activateAppCode}
${typeInstantWelcome.}
${type${s}${10}${20}}

await exec(a)
})()
`

$3

Execute commands from the passed array. It is an alternative way to write scripts which does not require to import aty and exec.

`javascript
/ yarn example/e.js /
import { e, activateApp, type } from 'aty'

(async () => {
await e([
activateAppTerminal,
typeecho hello world\n,
])
})()
`

$3

Wait for user to enter something via stdin. This command allows to pause executing a script, e.g., when it is necessary to wait for the result of typing, however how long to wait is unknown.

`javascript
/ yarn example/e.js /
import { e, w, activateApp, type } from 'aty'

(async () => {
await e([
activateAppTerminal,
typeecho hello world\n,
])
await w()
await e([
activateAppTerminal,
typedate\n,
])
})()
`

$3

This tagged template is used to generate the total code to be executed. It will include necessary types, and put all other blocks together. It should be used to generate a string to pass to the exec method.

`js
/ yarn example/hacker.js /
import { readFileSync } from 'fs'
import { resolve } from 'path'
import aty, {
type, typeInstant, activateApp, code, keystroke, delay,
} from 'aty'

const f = readFileSync(resolve(__dirname, __filename))

const a = aty
${activateAppCode}
${typeInstant/ recorded with appshot /}
${type${f}${15}${20}${true}}
${keystroke${'option'}${'shift'}f}
${delay2000}
${keystroke${'command'}a}
${delay1000}
${code51}

console.log(a)
`

`applescript
on type(the_string, delay_from, delay_to)
set theList to paragraphs of the_string
set listCount to count of theList

repeat with i from 1 to listCount
tell application "System Events"
repeat with c in item i of theList
keystroke c
delay (random number from delay_from to delay_to)
end repeat
if i is not listCount then key code 36
end tell
end repeat
end type
on typeInstant(the_string)
tell application "System Events"
keystroke the_string
key code 36
end tell
end type
activate application "Code"
typeInstant ("/ recorded with appshot /")
type ("/ yarn example/hacker.js /
import { readFileSync } from 'fs'
import { resolve } from 'path'
import aty, {
type, typeInstant, activateApp, code, keystroke, delay,
} from 'aty'

const f = readFileSync(resolve(__dirname, __filename))

const a = aty
${activateAppCode}
${typeInstant/ recorded with appshot /}
${type${f}${15}${20}${true}}
${keystroke${'option'}${'shift'}f}
${delay2000}
${keystroke${'command'}a}
${delay1000}
${code51}

console.log(a)", 0.015, 0.02)
tell application "System Events" to keystroke "f" using {option down, shift down}
delay 2
tell application "System Events" to keystroke "a" using command down
delay 1
tell application "System Events" to key code 51
`

$3

Activate an app with the given name.

`js
/ yarn example/activate-app.js /
import { activateApp } from 'aty'

const app = 'Terminal'

const a = activateApp${app}
const b = activateAppCode

console.log(a)
console.log(b)
`

`applescript
activate application "Terminal"
activate application "Code"
`

$3

The type template is used to generate a command to type a text into an application. It can be used after activateApp command to send text to a particular application. aty will automatically include the type function when type was used in the script. noIndent can be used to replace white spaces in the beginning of each line.

`js
/ yarn example/type.js /
import aty, { type } from 'aty'

const t = 'admin\\n'

const a = type${t}
const b = typeThough sympathy alone can't alter facts,
it can help to make them more bearable.

${50}${100}${true}

console.log(aty
${a}
${b}
)
`

`applescript
on type(the_string, delay_from, delay_to)
set theList to paragraphs of the_string
set listCount to count of theList

repeat with i from 1 to listCount
tell application "System Events"
repeat with c in item i of theList
keystroke c
delay (random number from delay_from to delay_to)
end repeat
if i is not listCount then key code 36
end tell
end repeat
end type
type ("admin\n", 0.05, 0.1)
type ("Though sympathy alone can't alter facts,
it can help to make them more bearable.
", 0.05, 0.1)
`

$3

Same as type, but will insert text immediately without a delay. When aty sees a string which begins with typeInstant, it will automatically include the typeInstant function.

`js
/ yarn example/type-instant.js /
import aty, { typeInstant } from 'aty'

const t = 'Type Instant Text'

const a = typeInstant${t}
const b = typeInstantDo you believe in destiny?
That even the powers of time can be altered for a single purpose?

console.log(aty
${a}
${b}
)
`

`applescript
on typeInstant(the_string)
tell application "System Events"
keystroke the_string
key code 36
end tell
end type
typeInstant ("Type Instant Text")
typeInstant ("Do you believe in destiny?
That even the powers of time can be altered for a single purpose?")
`


$3

Delay execution by n milliseconds.

`js
/ yarn example/delay.js /
import { delay } from 'aty'

const d = 100

const a = delay${d}
const b = delay500

console.log(a)
console.log(b)
`

`applescript
delay 0.1
delay 0.5
`

$3

Send a key stroke. If commands are provided, they will be included.

`js
/ yarn example/keystroke.js /
import { keystroke } from 'aty'

const a = keystrokea${'command'}
const b = keystrokes${'alt'}${'command'}

console.log(a)
console.log(b)
`

`applescript
tell application "System Events" to keystroke "a" using command down
tell application "System Events" to keystroke "s" using {alt down, command down}
`

$3

Send a code. If commands are provided, they will be included with using keyword. Some codes can be found in the Key Code Reference Table below.

`js
/ yarn example/code.js /
import { code } from 'aty'

const a = code36${'command'}
const b = code36${'command'}${'shift'}

console.log(a)
console.log(b)
`

`applescript
tell application "System Events" to key code 36 using command down
tell application "System Events" to key code 36 using {command down, shift down}
`

API Examples

Register Domain For Package: mnp-expensive: This example shows how to activate the Terminal app, and execute 4 commands, waiting for user-input to begin each, i.e., when any key rather than n is entered, aty will continue execution.

Key Code Reference Table

CLI

The package can be used from the CLI if installed globally. It can generate an apple script to activate an app specified with -a argument, and type text into it.

`sh
aty -h
`

$3

Arguments can be passed by specifying their value -arg value, e.g., -a app`.

CLI Examples

Click to View: aty "echo test\n" -i date -d 100 -a Terminal

Copyright

(c) [Art Deco][1] 2018

[1]: https://artdeco.bz