Here are the global api methods and their types. 
I'll add more explanation/organization soooooon :D

> Note: These are all proxied/lazy loaded. They won't be "required" until you actually invoke the method.

```js
cd: typeof shelljs.cd
cp: typeof shelljs.cp
chmod: typeof shelljs.chmod
echo: typeof shelljs.echo
exec: typeof shelljs.exec
exit: typeof shelljs.exit
grep: typeof shelljs.grep
ln: typeof shelljs.ln
ls: typeof shelljs.ls
mkdir: typeof shelljs.mkdir
mv: typeof shelljs.mv
sed: typeof shelljs.sed
tempdir: typeof shelljs.tempdir
test: typeof shelljs.test
which: typeof shelljs.which
rm: typeof trashType //use `trash` instead
spawn: typeof child_process.spawn
spawnSync: typeof child_process.spawnSync
fork: typeof child_process.fork

get: AxiosInstance["get"]
put: AxiosInstance["put"]
post: AxiosInstance["post"]
patch: AxiosInstance["patch"]

readFile: typeof fsPromises.readFile
writeFile: typeof fsPromises.writeFile
appendFile: typeof fsPromises.appendFile
createWriteStream: typeof fs.createWriteStream
readdir: typeof fsPromises.readdir

compile: typeof handlebars.compile_

cwd: typeof process.cwd
pid: typeof process.pid
stderr: typeof process.stderr
stdin: typeof process.stdin
stdout: typeof process.stdout
uptime: typeof process.uptime

path: typeof import("path")

_: LoDashStatic

uuid: typeof uuidType.v4
chalk: ChalkFunction
paste: typeof clipboardy.read
copy: typeof clipboardy.write

db: DB

trash: typeof trashType

wait: Wait

home: Path
isFile: IsCheck
isDir: IsCheck
isBin: IsCheck

tmp: Path
inspect: Inspect

compileTemplate: CompileTemplate

md: Markdown

applescript: AppleScript

setPlaceholder: SetAppProp
setPanel: SetAppProp
setHint: SetAppProp
setInput: SetAppProp
setIgnoreBlur: SetAppProp
setChoices: (choices: Choices<any>) => void

sendResponse: (value: any) => void


show: ShowAppWindow
showImage: ShowAppWindow

edit: Edit

terminal: (script: string) => Promise<string>
iterm: (iterm: string) => Promise<string>


notify: typeof notifyType
```

Global API

### `// Shortcut`

```js
// Shortcut: cmd opt shift ctrl a
```

Automatically assigns a keyboard shortcut to the script. Will update each time you save the file. You can also change shortcuts in `Main Menu -> Help -> Change script shortcut`

### `// Menu`

```js
// Menu: My Awesome Script
```

Customizes the name of the script in the main menu

### `// Description`

```js
// Description: This script does something awesome
```

Describes the script in the main menu

### `// Author` and `// Twitter`

Credits you when the script runs with a prompt

## ✨ New ✨ in Kit-1.3.0-beta.4

### `// Exclude`

```js
// Exclude: true
```

Hides the script from the Main Menu (can still be run from shortcuts, schedule, system, etc).

### `// Schedule`

```js
// Schedule: */10 * * * * *
```

Runs the script on a cron schedule.

### `// System`

```js
// System: unlock-screen
```

Runs the script on a system event. 

Available events:
* suspend
* resume
* on-ac
* on-battery
* shutdown
* lock-screen
* unlock-screen
* user-did-become-active
* user-did-resign-active



Read about the available events [here](https://www.electronjs.org/docs/api/power-monitor#events)


Metadata

> Shortcodes require Kit-1.3.0-beta.6.dmg

Shortcodes are like writing acronyms to quickly get to specific choices of a script.

To run the following script and select "Banana" and "Cookie" type "a", space, "b", space, "c":

```js
// Shortcode: a

let fruit = await arg("Type 'b' then spacebar", [
  {
    name: "Apple",
    value: "apple",
  },
  {
    name: "Banana",
    value: "banana",
    shortcode: "b",
  },
])

let treat = await arg("Type 'c' then spacebar", [
  {
    name: "Donut",
    value: "donut",
  },
  {
    name: "Cookie",
    value: "cookie",
    shortcode: "c",
  },
])

await arg(`${fruit}, ${treat}`)
```

Shortcodes also enable "English" shortcuts. From the main menu, type "go fish " or "go eat " to quickly drill down to one of these choices:

```js
//Shortcode: go

let message = await arg("Where?", [
  {
    name: "Lunch",
    shortcode: "eat",
    value: "Gone out to lunch",
  },
  {
    name: "Fishing",
    shortcode: "fish",
    value: "Gone fishin'",
  },
])

await arg(message)
```

Shortcodes

## Sponsor Script Kit
For $7/month, you can sponsor Script Kit and unlock Pro features.

Sponsoring helps with the development of Script Kit to help move the project forward. It also enables more advanced features for power users such as:

### Pro Features
- Debugger
- Script Log Window
- Audio Recording
- Support through Discord

### Upcoming Pro Features
- Sync Scripts to GitHub Repo
- Run Script Remotely as GitHub Actions
- Advanced Widgets
- Screenshots
- Screen Recording
- Webcam Capture
- Desktop Color Picker
- Measure Tool

[Open GitHub Sponsor Page](https://github.com/sponsors/johnlindquist/sponsorships?sponsor=johnlindquist&tier_id=235205)

Sponsorship FAQ

# Script Kit Process Lifecycle: Understanding the Process/Script/Prompt Relationships

## The Idle Process

When the app starts up, it initiates an idle process. This process does the following:

1. Loads `~/.kit/run/app-prompt.js` to preload the Script Kit libraries from the SDK

> Note: This will also preload the platform-specific code

2. Idles and waits for the user to submit a script
3. Enables quick script launching since the process is always ready to go

## Script Execution and Prompts

Prompts play a crucial role in Script, but they don't come into play unless the script uses one of the following prompts (grouped by similarity)

- `arg`, `mini`, `micro`
- `fields` and `form`
- `div` and `splash` (the install screen, used internally)
- `editor` and `textarea`(textarea is pretty much legacy, just use `editor`)
- `hotkey`
- `chat`
- `mic`
- `drop`


Since everything in Script Kit is done "just in time," the app doesn't know what will display until the script hits a prompt. When a prompt is encountered, the following occurs:

1. Sends prompt type/data to the app
2. The app displays the data to the user (e.g., list or HTML)
3. Waits for a submit action before proceeding to the next step

Each time a prompt is hit, the script waits for the user to submit the prompt before moving forward. When the user triggers the submit event, the script will continue exectuing with the data received from the user. While a script is waiting for the "submit" event from the app, you can leverage a few event handlers such as:

- `onInit` (right after the app receives the prompt config)
- `onInput`
- `onBlur`
- `onChoiceFocus`
- `onSubmit` (right before the script continues from the prompt. Last chance to get data from the app)
- and more...

These are all based on the following interface:
```js
export interface ChannelHandler {
  (input?: string, state?: AppState): void | Promise<void>
}
```

These "ChannelHandlers" are how the app communicates back to the script. These deserve a blog post of their own.

## The Main Menu

The main menu is a script just like any you authored. The main shortcut (`cmd+;` by default) will the the `~/.kit/run/app-prompt.js` to run the `~/.kit/main/index.js` script. 

Any custom keyboard shortcuts (or other script triggers) you've set up will load your `~/.kenv/scripts/your-script.js` and will not load the main menu.

What makes the main menu feel different is that it's a script that loads another script. In JavaScript terms, it's a module which imports another module.

Also, the default behavior for many prompts `onEscape` handler is to "run the main menu script", so it can definitely feel more special than your script. Rest assured that the main menu is "just a script" that leverages many of more advanced Script Kit features.

## Script Termination and Process Management

Now that the process has loaded the SDK and has imported your script, the process will terminate once the script has run all of its code. So the script has either run out of promises/prompts to wait for, event handlers to listen to, or you've blurred/escaped or triggered another event from the app that told the script to end prematurely.

While your script is running, the Script Kit app will always start another idle process in the background to be ready for the next script sent by the user.

## Recap

The core basics of the Script Kit process lifecycle can be summarized as follows:

1. The app starts an idle process that preloads the Script Kit SDK.
2. The idle process waits for the the script (AKA JavaScript module)
3. When a script is sent to the idle process, the app runs through the script and displays prompts when necessary.
4. The process waits for the user to input and submit for each prompt.
5. Once the script has executed all of its code, the process terminates.


The Script Kit Process Lifecycle


### `await arg()`

```js
let input = await arg()
```

Launches the prompt, waits for user input.

### `await env("SOME_TOKEN")`

```js
let SOME_TOKEN = await env("SOME_TOKEN")
```

Launches the prompt if var isn't found in `.env`. Waits for user input. Automatically stores var in `.env`.


### `await drop()`

```js
let dropData = await drop()
```

Launches the prompt as a drop target.



### `await hotkey()`

```js
let keyInfo = await hotkey()
```

Launches the prompt and waits for a key combination.

