Terminal Notifier

Receive mobile-friendly status updates for terminal runs in VS Code.

Terminal Notifier helps you start a command from VS Code, watch the live output in a compact panel, interact with simple prompts when needed, and receive a concise completion message when the run ends.

It is built for local development workflows where commands may take time: model training, evaluation scripts, data preprocessing, builds, tests, simulations, and other terminal runs that you do not want to babysit.

Start a run
    ↓
Watch live output
    ↓
Send input if the program asks
    ↓
Receive a compact completion update

What is new in v1.1.0

Terminal Notifier is no longer just a simple completion notifier. Version 1.1.0 adds a much stronger active-run workflow:

Live output preview inside the Notifier panel.
Scrollable active-run output that does not expand the whole UI.
Active input box for simple interactive programs.
Send, Send empty line, Stop, Open terminal, and Clear output controls.
Persistent current directory per workspace.
cd command handling that updates the Notifier current directory.
Environment modes for common workflows:
- None
- Conda environment
- Python executable
- Custom prefix
Better support for Python and ML workflows.
Stronger stop behavior for long-running processes.
Cleaner final notification formatting.

Highlights

Dedicated Notifier bottom-panel UI.
Terminal bell shortcut for quick Run + Notify.
Mobile-friendly completion messages.
Telegram and Discord delivery options.
Final Output and Full Terminal output modes.
Live output preview while the command is running.
Scrollable active run panel.
Clear Output button for the UI preview.
Local logs for every run.
Workspace-specific command history.
Current directory memory.
Environment selection for Conda and Python executable workflows.
No separate local backend server required.

Main workflows

1. Notifier panel

Open the bottom panel tab named Notifier.

Use it to:

Choose a notification channel.
Configure the channel once.
Test the channel.
Set the current directory.
Choose an environment mode.
Enter a command.
Watch live output.
Send input to an active run.
Stop an active run.
Open the full terminal view.
Open local logs.

This is the recommended workflow.

2. Terminal bell shortcut

Terminal Notifier also adds a bell shortcut in the Terminal panel.

Use it when your channel is already configured and you want a quick command prompt flow.

Active run panel

When a command is running, Terminal Notifier shows an active-run section with:

Current run state.
Live output preview.
Input box for simple prompts.
Send button.
Send empty line button.
Stop button.
Open terminal button.
Clear output button.

The live output preview is scrollable. It is meant for context, not as a replacement for the full terminal log.

Clear output only clears the visible preview. It does not change the real run output, local logs, or the final completion message.

Current directory

Terminal Notifier keeps a current directory per workspace.

You can:

Edit the directory field.
Use the workspace root button.
Browse for a folder.
Run cd commands from the command box.

Example:

cd .\scripts

Terminal Notifier updates its current directory instead of running cd as a short-lived process.

This means the next command runs from the updated directory.

Environment modes

Terminal Notifier supports four environment modes.

None

Runs the command as-is from the selected current directory.

Example:

python script.py

Conda environment

Use this for non-interactive Conda jobs.

You enter only the environment name.

python3.10env

Then run a normal command:

python scripts\train.py --epochs 5

Terminal Notifier builds the Conda run command internally.

This is recommended for training, evaluation, and other non-interactive scripts.

Python executable

Use this for interactive Python scripts or when you want a specific Python interpreter.

Example Python executable:

C:\Users\you\anaconda3\envs\python3.10env\python.exe

Example command:

scripts\inference.py --interactive

This mode is useful when the script uses input() prompts.

Custom prefix

Use this only when you know exactly what prefix your command needs.

Example:

poetry run

Then command:

python train.py

The effective run becomes:

poetry run python train.py

Output modes

Final Output

Recommended for long-running jobs.

Final Output sends the most relevant final lines of the run. It is designed for mobile readability and avoids sending huge progress logs when possible.

Best for:

Training summaries.
Final metrics.
Validation results.
Completion messages.
Last error traceback.
Short final reports.

Setting:

{
  "terminalNotifier.finalOutputLineCount": 80
}

Full Terminal

Full Terminal includes a broader capture of the run output up to the configured notification size limit.

Best for:

Short scripts.
Debug runs.
Small build logs.
Cases where the full printed output matters.

Setting:

{
  "terminalNotifier.maxNotificationCharacters": 12000
}

If output is too long, the completion message is shortened and the full log remains available locally.

Example completion message

🔔 ✅ 2m 14s | exit 0

Mode:    Final Output
Dir:     A:\Projects\Model
Cmd:     python train.py --epochs 5

────────────────
epoch 4 val_acc=0.921
epoch 5 val_acc=0.928
best_val_acc=0.928
training_complete

Telegram setup

Telegram setup only needs to be done once.

Open Telegram.
Create a bot using BotFather.
Copy the value BotFather gives you.
Send a message to your bot, such as hello.
Open the Notifier panel.
Select Telegram.
Paste the value into the Telegram field.
Click Fetch Chat ID.
Select the detected chat.
Click Save.
Click Test.

After the test succeeds, you can run commands and receive completion updates.

Keep the Telegram connection value private.

Discord setup

Discord setup uses a channel connection URL.

Open Discord.
Open your server.
Choose the target channel.
Open channel settings.
Open Integrations.
Create a webhook.
Copy the channel URL.
Open the Notifier panel.
Select Discord.
Paste the URL.
Click Save.
Click Test.

After the test succeeds, the selected channel can receive completion updates.

Keep the Discord channel URL private.

Command history

Terminal Notifier remembers recent commands per workspace.

Use:

Ctrl + ↑
Ctrl + ↓

or:

↑ Prev
↓ Next

Behavior:

History is workspace-specific.
Commands are saved automatically when run.
Duplicate commands move to the top.
Editing the command box resets the history cursor.

Local logs

Every run saves local files under:

.vscode/terminal-notifier/logs/

Logs are useful when:

A completion message was shortened.
You need full run output.
You want to inspect a failed run.
You want to compare earlier runs.

Recommended .gitignore entry:

.vscode/terminal-notifier/

Recommended training setup

For training jobs such as:

python train.py --epochs 5

Recommended settings:

Environment: Conda environment or Python executable
Output mode: Final Output

Make sure your training script prints final metrics clearly:

print(f"best_val_acc={best_val_acc}", flush=True)
print(f"final_test_acc={test_acc}", flush=True)
print("training_complete", flush=True)

This makes the completion message much more useful.

Recommended interactive setup

For simple Python interactive scripts:

Environment: Python executable
Output mode: Full Terminal

Example command:

scripts\inference.py --interactive

Use the active-run input box to respond to prompts.

For complex full-screen terminal programs, use a normal terminal. Terminal Notifier supports simple stdin-style interactions, not full terminal emulation.

Privacy and local data

Terminal Notifier stores channel settings locally through VS Code secure storage.

Generated logs stay in your workspace.

Do not commit:

Local run logs.
Private connection values.
Sensitive command output.
Generated payload files.

Limitations

Terminal Notifier runs commands locally through VS Code.

That means:

VS Code must stay open.
Your computer must stay awake.
Only commands started through Terminal Notifier are captured.
Already-running terminals are not captured.
Very long output may be shortened in the completion message.
Full logs are saved locally.
Simple interactive prompts are supported, but full terminal emulation is not the goal.

Extension settings