Task Manager

Task Manager is a VS Code extension for discovering, organising, running, and monitoring tasks from three sources:

• Deno tasks from deno.json and deno.jsonc
• Package scripts from package.json
• Bash scripts from .sh files

Tasks from every source can be pinned into shared groups, reordered with drag-and-drop, given custom labels, and run in dedicated terminals.

Requirements

• VS Code ^1.116.0
• Deno for tasks shown in Deno Tasks
• Node.js and npm for tasks shown in Package Scripts
• Bash for tasks shown in Shell Scripts

Only the tools needed by the task you run have to be installed.

Getting started

1. Open a folder or multi-root workspace containing a supported task file.
2. Open the Task Manager icon in the Activity Bar.
3. Expand Deno Tasks, Package Scripts, or Shell Scripts to browse discovered tasks.
4. Add useful tasks to Pinned Tasks by dragging them into a group or using Add Task to Group from their context menu.
5. Use the play and stop actions in Pinned Tasks to control tasks.

The extension activates automatically when the workspace contains a deno.json, deno.jsonc, package.json, or .sh file.

Task views

Pinned Tasks

Pinned Tasks is the main working view. It combines Deno, package, and shell tasks into user-defined groups. Groups and custom labels are stored in workspace settings, so the same layout is restored the next time the workspace opens.

Each group shows the number of configured tasks. Expand a group to see its resolved tasks and their current status.

Deno Tasks

This view discovers every deno.json and deno.jsonc beneath the workspace, excluding node_modules and .git. Config files are shown as folders and their tasks entries are shown as children.

Deno entries are executed through deno task using the exact config file and, by default, the directory containing that file. Running through Deno rather than executing the task body directly means that:

• names containing colons, such as load:static-data, work normally;
• object-form tasks retain their descriptions;
• task dependencies are honoured;
• dependency-only tasks can be run.

Select a task to open its definition in the corresponding Deno config file.

Deno task working directories

Deno normally runs a task from the directory containing its config file. Some tasks instead use paths relative to the open workspace or the surrounding Git repository.

By default, the extension selects the directory automatically. Ordinary tasks use the config directory. If a task command references INIT_CWD, it uses the nearest Git repository root, or the workspace folder root when no repository is found. This makes repository-relative commands work without per-task setup.

To override the automatic choice, right-click a task in Deno Tasks and select Set Task Working Directory…:

• Automatic (Default) — infer the appropriate directory from the task command;
• Task config directory — use the folder containing deno.json or deno.jsonc;
• Workspace folder root — use the root of the VS Code workspace folder containing the config;
• Git repository root — use the nearest parent containing a .git directory or worktree .git file.

Explicit choices are stored per task in workspace settings. The extension passes both the exact config file and selected working directory to deno task and removes stale inherited INIT_CWD values, so nested configs, relative paths, dependencies, and invocation paths work consistently. Changing the directory closes an inactive task terminal so its next run starts in the new location; stop a running task before changing it.

Package Scripts

This view discovers scripts from every package.json beneath the workspace, excluding node_modules and .git. Each script runs as npm run "<script-name>" with the package directory as its working directory.

Select a script to open its definition in package.json.

Shell Scripts

This view discovers .sh files beneath the workspace, excluding node_modules and .git. Scripts are grouped by their directory and run with Bash from that directory. A script does not need its executable bit set because the extension invokes it through bash.

Select a shell task to open the script at its first line.

Adding and removing pinned tasks

Context menu

Right-click a task in any source view and choose Add Task to Group → Choose Group…. The group picker shows every current pinned group.

The source views support multiple selection. Select several tasks before opening the context menu to add all of them to the chosen group in one operation. A task already present in that group is not duplicated.

Drag-and-drop

You can:

• drag one or several source tasks onto a pinned group;
• drop source tasks on empty space in Pinned Tasks to create/use the automatic Ungrouped group;
• reorder tasks inside a group;
• move tasks between groups;
• reorder entire groups;
• drag pinned tasks back to a source view to unpin them.

The automatic Ungrouped group is removed when its final task is removed.

Remove Task

Right-click a pinned task and select Remove Task. With several pinned tasks selected, the command removes every selected task, including selections spanning different groups.

Removing a task only unpins it. It does not edit or delete the underlying Deno config, package file, or shell script.

Running and stopping tasks

Run one task

Use the play button or Run Task context-menu action on a pinned task. Every task gets a dedicated terminal. Package and shell tasks use their task file's directory; Deno tasks use the automatically resolved or explicitly selected directory described above. The extension reuses that terminal for later runs of the same task.

Terminal tabs use readable titles such as Shell: hello.sh — scripts/hello.sh. Encoded values such as shell:0:scripts%2fhello.sh:hello.sh are internal stable identifiers and remain confined to workspace settings and task tracking.

Selecting a pinned task focuses its existing terminal. It does not start a second copy.

Stop one task

While a task is starting or running, use the stop button or Stop Task. Running commands receive Ctrl+C; a task that is still waiting for terminal shell integration is cancelled before execution.

Start or stop a group

Use Start All Tasks on a group to start all resolved tasks in that group. Use Stop All Tasks to stop every task in the group that is currently starting or running. Finished and failed terminals are left untouched.

This is useful for groups containing several development servers, watchers, or related services.

Task status

When VS Code terminal shell integration is available, pinned tasks display live state:

Stopping a task clears its active state. Closing a task terminal also clears the state when it was closed by the user.

If shell integration is not detected, the extension offers to show setup instructions, run the task once without tracking, or always run without tracking. See the setting below.

Managing groups and labels

Use the actions in the Pinned Tasks view to:

• Create Group from the view title;
• Rename Group from a group's context menu;
• Delete Group and all of its pin entries;
• Rename Task to set a custom display label without modifying the source task.

Ungrouped is reserved for the automatic drag-and-drop group and cannot be used when renaming a normal group.

Refresh and configuration changes

Saving a supported task file refreshes its source view and the Pinned Tasks view. The Refresh action can be used after creating, deleting, or externally modifying files.

Changes to asfreitas.task-manager workspace settings are applied immediately. Reloading the extension is not required when groups or labels are edited directly in .vscode/settings.json.

Git worktrees and multi-root workspaces

Task identities use their source type, workspace-folder position, task-file path relative to the workspace root, and task name. They do not contain the absolute checkout path. As a result, pins created in workspace settings continue to resolve when the same repository is opened from a Git worktree with a different directory name.

Older Deno pins used a directory-based key. The extension continues to resolve those legacy keys when the matching task is unambiguous.

In a multi-root workspace, each workspace folder is searched independently and tasks run from the directory containing their own definition.

Extension settings