Add secrets, variables, and inputs to storage

Signed-off-by: Sanjula Ganepola <sanjulagane@gmail.com>

package.json

@@ -259,12 +259,6 @@
         "command": "githubLocalActions.addRunner",
         "title": "Add Runner",
         "icon": "$(add)"
-      },
-      {
-        "category": "GitHub Local Actions",
-        "command": "githubLocalActions.editContainerEngine",
-        "title": "Edit Container Engine",
-        "icon": "$(edit)"
       }
     ],
     "menus": {
@@ -352,10 +346,6 @@
         {
           "command": "githubLocalActions.addRunner",
           "when": "never"
-        },
-        {
-          "command": "githubLocalActions.editContainerEngine",
-          "when": "never"
         }
       ],
       "view/title": [
@@ -480,11 +470,6 @@
           "command": "githubLocalActions.addRunner",
           "when": "view == settings && viewItem =~ /^githubLocalActions.runners.*/",
           "group": "inline@0"
-        },
-        {
-          "command": "githubLocalActions.editContainerEngine",
-          "when": "view == settings && viewItem =~ /^githubLocalActions.containerEngine(?!s).*/",
-          "group": "inline@0"
         }
       ]
     },

src/act.ts

@@ -45,10 +45,67 @@ export enum Event {
 }
 
 export enum Option {
-    Workflows = '--workflows',
+    ActionCachePath = '--action-cache-path',
+    ActionOfflineMode = '--action-offline-mode',
+    Actor = '--actor',
+    ArtifactServerAddr = '--artifact-server-addr',
+    ArtifactServerPath = '--artifact-server-path',
+    ArtifactServerPort = '--artifact-server-port',
+    Bind = '--bind',
+    BugReport = '--bug-report',
+    CacheServerAddr = '--cache-server-addr',
+    CacheServerPath = '--cache-server-path',
+    CacheServerPort = '--cache-server-port',
+    ContainerArchitecture = '--container-architecture',
+    ContainerCapAdd = '--container-cap-add',
+    ContainerCapDrop = '--container-cap-drop',
+    ContainerDaemonSocket = '--container-daemon-socket',
+    ContainerOptions = '--container-options',
+    DefaultBranch = '--defaultbranch',
+    DetectEvent = '--detect-event',
+    Directory = '--directory',
+    DryRun = '--dryrun',
+    Env = '--env',
+    EnvFile = '--env-file',
+    EventPath = '--eventpath',
+    GitHubInstance = '--github-instance',
+    Graph = '--graph',
+    Help = '--help',
+    Input = '--input',
+    InputFile = '--input-file',
+    InsecureSecrets = '--insecure-secrets',
     Job = '--job',
-    Variable = '--var',
+    Json = '--json',
-    Json = "--json"
+    List = '--list',
+    LocalRepository = '--local-repository',
+    LogPrefixJobId = '--log-prefix-job-id',
+    ManPage = '--man-page',
+    Matrix = '--matrix',
+    Network = '--network',
+    NoCacheServer = '--no-cache-server',
+    NoRecurse = '--no-recurse',
+    NoSkipCheckout = '--no-skip-checkout',
+    Platform = '--platform',
+    Privileged = '--privileged',
+    Pull = '--pull',
+    Quiet = '--quiet',
+    Rebuild = '--rebuild',
+    RemoteName = '--remote-name',
+    ReplaceGHEActionTokenWithGitHubCom = '--replace-ghe-action-token-with-github-com',
+    ReplaceGHEActionWithGitHubCom = '--replace-ghe-action-with-github-com',
+    Reuse = '--reuse',
+    Rm = '--rm',
+    Secret = '--secret',
+    SecretFile = '--secret-file',
+    UseGitignore = '--use-gitignore',
+    UseNewActionCache = '--use-new-action-cache',
+    Userns = '--userns',
+    Var = '--var',
+    VarFile = '--var-file',
+    Verbose = '--verbose',
+    Version = '--version',
+    Watch = '--watch',
+    Workflows = '--workflows'
 }
 
 export interface CommandArgs {
@@ -73,7 +130,7 @@ export class Act {
         this.componentsManager = new ComponentsManager();
         this.workflowsManager = new WorkflowsManager();
         this.historyManager = new HistoryManager(this.storageManager);
-        this.settingsManager = new SettingsManager();
+        this.settingsManager = new SettingsManager(this.storageManager);
 
         switch (process.platform) {
             case 'win32':

src/settingsManager.ts

@@ -1,14 +1,6 @@
 import { WorkspaceFolder } from "vscode";
-import { Workflow } from "./workflowsManager";
+import { act } from "./extension";
-
+import { StorageKey, StorageManager } from "./storageManager";
-export interface Settings {
-    environments: Environment[],
-    secrets: Secret[],
-    variables: Variable[],
-    inputs: Input[],
-    runners: Runner[],
-    containerEngines: ContainerEngine[]
-}
 
 export interface Environment {
     name: string
@@ -38,115 +30,105 @@ export interface Runner {
     selected: boolean
 }
 
-export interface ContainerEngine {
-    key: string,
-    value: string,
-    selected: boolean
-}
-
 export class SettingsManager {
-    settings: { [path: string]: Settings }
+    storageManager: StorageManager;
 
-    constructor() {
+    constructor(storageManager: StorageManager) {
-        this.settings = {};
+        this.storageManager = storageManager;
     }
 
-    getSettings(workspaceFolder: WorkspaceFolder) {
+    async getEnvironments(workspaceFolder: WorkspaceFolder): Promise<Environment[]> {
-        if (!this.settings[workspaceFolder.uri.fsPath]) {
-            this.settings[workspaceFolder.uri.fsPath] = {
-                environments: [],
-                secrets: [],
-                variables: [],
-                inputs: [],
-                runners: [],
-                containerEngines: [
-                    {
-                        key: 'DOCKER_HOST',
-                        value: '',
-                        selected: false
-                    }
-                ]
-            }
-        }
-
-        return this.settings[workspaceFolder.uri.fsPath];
-    }
-
-    getEnvironments(workflow: Workflow): Environment[] {
         const environments: Environment[] = [];
+
+        const workflows = await act.workflowsManager.getWorkflows(workspaceFolder);
+        for (const workflow of workflows) {
             if (!workflow.yaml) {
-            return environments;
+                continue;
             }
 
             const jobs = workflow.yaml?.jobs;
             if (jobs) {
                 for (const details of Object.values<any>(jobs)) {
                     if (details.environment) {
+                        const existingEnvironment = environments.find(environment => environment.name === details.environment);
+                        if (!existingEnvironment) {
                             environments.push({
                                 name: details.environment
                             });
                         }
                     }
                 }
+            }
+        }
 
         return environments;
     }
     
-    getSecrets(workflow: Workflow): Secret[] {
+
-        const secrets: Secret[] = [];
+    async getSetting<T extends Secret | Variable | Input>(workspaceFolder: WorkspaceFolder, regExp: RegExp, storageKey: StorageKey): Promise<T[]> {
+        const existingSettings = this.storageManager.get<{ [path: string]: T[] }>(storageKey) || {};
+
+        const settings: T[] = [];
+
+        const workflows = await act.workflowsManager.getWorkflows(workspaceFolder);
+        for (const workflow of workflows) {
             if (!workflow.fileContent) {
-            return secrets;
+                continue;
             }
 
-        return this.findInWorkflow(workflow.fileContent, /\${{\s*secrets\.(.*?)\s*}}/g);
+            settings.push(...this.findInWorkflow<T>(workflow.fileContent, regExp));
         }
 
-    getVariables(workflow: Workflow): Variable[] {
+        if (existingSettings[workspaceFolder.uri.fsPath]) {
-        const variables: Variable[] = [];
+            for (const [index, setting] of settings.entries()) {
-        if (!workflow.fileContent) {
+                const existingSetting = existingSettings[workspaceFolder.uri.fsPath].find(existingSetting => existingSetting.key === setting.key);
-            return variables;
+                if (existingSetting) {
+                    settings[index] = {
+                        key: setting.key,
+                        value: existingSetting.value,
+                        selected: existingSetting.selected
+                    } as T;
+                }
+            }
+        }
+        existingSettings[workspaceFolder.uri.fsPath] = settings;
+        this.storageManager.update(storageKey, existingSettings);
+
+        return settings;
     }
 
-        return this.findInWorkflow(workflow.fileContent, /\${{\s*vars\.(.*?)(?:\s*==\s*(.*?))?\s*}}/g);
+    editSetting<T extends Secret | Variable | Input>(workspaceFolder: WorkspaceFolder, newSetting: T, storageKey: StorageKey) {
+        const existingSettings = this.storageManager.get<{ [path: string]: T[] }>(storageKey) || {};
+        if (existingSettings[workspaceFolder.uri.fsPath]) {
+            const index = existingSettings[workspaceFolder.uri.fsPath].findIndex(setting => setting.key === newSetting.key);
+            if (index > -1) {
+                existingSettings[workspaceFolder.uri.fsPath][index] = newSetting;
+            } else {
+                existingSettings[workspaceFolder.uri.fsPath].push(newSetting);
+            }
+        } else {
+            existingSettings[workspaceFolder.uri.fsPath] = [newSetting];
         }
 
-    getInputs(workflow: Workflow): Input[] {
+        this.storageManager.update(storageKey, existingSettings);
-        const inputs: Variable[] = [];
-        if (!workflow.fileContent) {
-            return inputs;
     }
 
-        return this.findInWorkflow(workflow.fileContent, /\${{\s*(?:inputs|github\.event\.inputs)\.(.*?)(?:\s*==\s*(.*?))?\s*}}/g);
+    private findInWorkflow<T extends Secret | Variable | Input>(content: string, regExp: RegExp) {
+        const results: (T)[] = [];
+
+        const matches = content.matchAll(regExp);
+        for (const match of matches) {
+            results.push({ key: match[1], value: '', selected: false } as T);
         }
 
-    editSecret(workspaceFolder: WorkspaceFolder, secret: Secret, newValue: string) {
+        return results;
-
     }
 
-    editVariable(workspaceFolder: WorkspaceFolder, variable: Variable, newValue: string) {
+    getRunners(workspaceFolder: WorkspaceFolder): Runner[] {
-
+        return [];
-    }
-
-    editInput(workspaceFolder: WorkspaceFolder, input: Input, newValue: string) {
-
     }
 
     addRunner(workspaceFolder: WorkspaceFolder, runner: Runner) {
 
     }
-
-    editContainerEngine(workspaceFolder: WorkspaceFolder, containerEngine: ContainerEngine, newValue: string) {
-
-    }
-
-    private findInWorkflow(content: string, regExp: RegExp) {
-        const results: (Secret | Variable | Input)[] = [];
-
-        const matches = content.matchAll(regExp);
-        for (const match of matches) {
-            results.push({ key: match[1], value: '', selected: false });
-        }
-
-        return results;
-    }
 }

src/storageManager.ts

@@ -1,12 +1,15 @@
 import { ExtensionContext } from "vscode";
 
 export enum StorageKey {
-    WorkspaceHistory = 'workspaceHistory'
+    WorkspaceHistory = 'workspaceHistory',
+    Secrets = 'secrets',
+    Variables = 'variables',
+    Inputs = 'inputs'
 }
 
 export class StorageManager {
     private context: ExtensionContext;
-    private storageKey: string = 'githubLocalActions';
+    private extensionKey: string = 'githubLocalActions';
 
     constructor(context: ExtensionContext) {
         this.context = context;
@@ -16,11 +19,11 @@ export class StorageManager {
         return this.context.globalState.keys();
     }
 
-    get<T>(key: StorageKey): T | undefined {
+    get<T>(storageKey: StorageKey): T | undefined {
-        return this.context.globalState.get<T>(`${this.storageKey}.${key}`);
+        return this.context.globalState.get<T>(`${this.extensionKey}.${storageKey}`);
     }
 
-    async update(key: StorageKey, value: any): Promise<void> {
+    async update(storageKey: StorageKey, value: any): Promise<void> {
-        await this.context.globalState.update(`${this.storageKey}.${key}`, value);
+        await this.context.globalState.update(`${this.extensionKey}.${storageKey}`, value);
     }
 }

src/views/history/historyTreeDataProvider.ts

@@ -70,7 +70,7 @@ export default class HistoryTreeDataProvider implements TreeDataProvider<GithubL
             const workspaceFolders = workspace.workspaceFolders;
             if (workspaceFolders) {
                 if (workspaceFolders.length === 1) {
-                    return await new WorkspaceFolderHistoryTreeItem(workspaceFolders[0]).getChildren();
+                    items.push(...await new WorkspaceFolderHistoryTreeItem(workspaceFolders[0]).getChildren());
                 } else if (workspaceFolders.length > 1) {
                     for (const workspaceFolder of workspaceFolders) {
                         items.push(new WorkspaceFolderHistoryTreeItem(workspaceFolder));

src/views/settings/containerEngine.ts

@@ -1,18 +0,0 @@
-import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
-import { ContainerEngine } from "../../settingsManager";
-import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
-
-export default class ContainerEngineTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
-    static contextValue = 'githubLocalActions.containerEngine';
-
-    constructor(public workspaceFolder: WorkspaceFolder, containerEngine: ContainerEngine) {
-        super(containerEngine.key, TreeItemCollapsibleState.None);
-        this.description = containerEngine.value;
-        this.contextValue = ContainerEngineTreeItem.contextValue;
-        this.iconPath = new ThemeIcon('code');
-    }
-
-    async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
-        return [];
-    }
-}

src/views/settings/containerEngines.ts

@@ -1,25 +0,0 @@
-import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
-import { act } from "../../extension";
-import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
-import ContainerEngineTreeItem from "./containerEngine";
-
-export default class ContainerEnginesTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
-    static contextValue = 'githubLocalActions.containerEngines';
-
-    constructor(public workspaceFolder: WorkspaceFolder) {
-        super('Container Engines', TreeItemCollapsibleState.Collapsed);
-        this.contextValue = ContainerEnginesTreeItem.contextValue;
-        this.iconPath = new ThemeIcon('server-process');
-    }
-
-    async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
-        const items: GithubLocalActionsTreeItem[] = [];
-
-        const containerEngines = act.settingsManager.getSettings(this.workspaceFolder).containerEngines;
-        for (const containerEngine of containerEngines) {
-            items.push(new ContainerEngineTreeItem(this.workspaceFolder, containerEngine));
-        }
-
-        return items;
-    }
-}

src/views/settings/environment.ts

@@ -4,9 +4,11 @@ import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
 
 export default class EnvironmentTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
     static contextValue = 'githubLocalActions.environment';
+    environment: Environment;
 
     constructor(public workspaceFolder: WorkspaceFolder, environment: Environment) {
         super(environment.name, TreeItemCollapsibleState.None);
+        this.environment = environment;
         this.contextValue = EnvironmentTreeItem.contextValue;
         this.iconPath = new ThemeIcon('server');
     }

src/views/settings/environments.ts

@@ -13,8 +13,13 @@ export default class EnvironmentsTreeItem extends TreeItem implements GithubLoca
     }
 
     async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
-        const workflows = await act.workflowsManager.getWorkflows(this.workspaceFolder);
+        const items: GithubLocalActionsTreeItem[] = [];
-        const environments = [...new Set(workflows.map(workflow => act.settingsManager.getEnvironments(workflow)).flat())];
+
-        return environments.map(environment => new EnvironmentTreeItem(this.workspaceFolder, environment));
+        const environments = await act.settingsManager.getEnvironments(this.workspaceFolder);
+        for (const environment of environments) {
+            items.push(new EnvironmentTreeItem(this.workspaceFolder, environment));
+        }
+
+        return items;
     }
 }

src/views/settings/input.ts

@@ -4,13 +4,15 @@ import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
 
 export default class InputTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
     static contextValue = 'githubLocalActions.input';
+    input: Input
 
     constructor(public workspaceFolder: WorkspaceFolder, input: Input) {
         super(input.key, TreeItemCollapsibleState.None);
+        this.input = input;
         this.description = input.value;
         this.contextValue = InputTreeItem.contextValue;
         this.iconPath = new ThemeIcon('symbol-parameter');
-        this.checkboxState = TreeItemCheckboxState.Unchecked;
+        this.checkboxState = input.selected ? TreeItemCheckboxState.Checked : TreeItemCheckboxState.Unchecked;
     }
 
     async getChildren(): Promise<GithubLocalActionsTreeItem[]> {

src/views/settings/inputs.ts

@@ -1,5 +1,6 @@
 import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
 import { act } from "../../extension";
+import { StorageKey } from "../../storageManager";
 import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
 import InputTreeItem from "./input";
 
@@ -13,8 +14,13 @@ export default class InputsTreeItem extends TreeItem implements GithubLocalActio
     }
 
     async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
-        const workflows = await act.workflowsManager.getWorkflows(this.workspaceFolder);
+        const items: GithubLocalActionsTreeItem[] = [];
-        const inputs = [...new Set(workflows.map(workflow => act.settingsManager.getInputs(workflow)).flat())];
+
-        return inputs.map(input => new InputTreeItem(this.workspaceFolder, input));
+        const inputs = await act.settingsManager.getSetting(this.workspaceFolder, /\${{\s*(?:inputs|github\.event\.inputs)\.(.*?)(?:\s*==\s*(.*?))?\s*}}/g, StorageKey.Inputs);
+        for (const input of inputs) {
+            items.push(new InputTreeItem(this.workspaceFolder, input));
+        }
+
+        return items;
     }
 }

src/views/settings/secret.ts

@@ -4,13 +4,15 @@ import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
 
 export default class SecretTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
     static contextValue = 'githubLocalActions.secret';
+    secret: Secret;
 
     constructor(public workspaceFolder: WorkspaceFolder, secret: Secret) {
         super(secret.key, TreeItemCollapsibleState.None);
+        this.secret = secret;
         this.description = secret.value ? '••••••••' : '';
         this.contextValue = SecretTreeItem.contextValue;
         this.iconPath = new ThemeIcon('key');
-        this.checkboxState = TreeItemCheckboxState.Unchecked;
+        this.checkboxState = secret.selected ? TreeItemCheckboxState.Checked : TreeItemCheckboxState.Unchecked;
     }
 
     async getChildren(): Promise<GithubLocalActionsTreeItem[]> {

src/views/settings/secrets.ts

@@ -1,5 +1,6 @@
 import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
 import { act } from "../../extension";
+import { StorageKey } from "../../storageManager";
 import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
 import SecretTreeItem from "./secret";
 
@@ -13,8 +14,13 @@ export default class SecretsTreeItem extends TreeItem implements GithubLocalActi
     }
 
     async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
-        const workflows = await act.workflowsManager.getWorkflows(this.workspaceFolder);
+        const items: GithubLocalActionsTreeItem[] = [];
-        const secrets = [...new Set(workflows.map(workflow => act.settingsManager.getSecrets(workflow)).flat())];
+
-        return secrets.map(secret => new SecretTreeItem(this.workspaceFolder, secret));
+        const secrets = await act.settingsManager.getSetting(this.workspaceFolder, /\${{\s*secrets\.(.*?)\s*}}/g, StorageKey.Secrets);
+        for (const secret of secrets) {
+            items.push(new SecretTreeItem(this.workspaceFolder, secret));
+        }
+
+        return items;
     }
 }

src/views/settings/settingsTreeDataProvider.ts

@@ -1,7 +1,7 @@
-import { CancellationToken, commands, EventEmitter, ExtensionContext, TreeDataProvider, TreeItem, workspace } from "vscode";
+import { CancellationToken, commands, EventEmitter, ExtensionContext, TreeDataProvider, TreeItem, window, workspace } from "vscode";
 import { act } from "../../extension";
+import { StorageKey } from "../../storageManager";
 import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
-import ContainerEngineTreeItem from "./containerEngine";
 import InputTreeItem from "./input";
 import RunnersTreeItem from "./runners";
 import SecretTreeItem from "./secret";
@@ -19,19 +19,44 @@ export default class SettingsTreeDataProvider implements TreeDataProvider<Github
                 this.refresh();
             }),
             commands.registerCommand('githubLocalActions.editSecret', async (secretTreeItem: SecretTreeItem) => {
-                //TODO: Implement
+                const newValue = await window.showInputBox({
+                    prompt: `Enter the value for ${secretTreeItem.secret.value}`,
+                    placeHolder: `Secret value`,
+                    value: secretTreeItem.secret.value,
+                    password: true
+                });
+
+                if (newValue) {
+                    act.settingsManager.editSetting(secretTreeItem.workspaceFolder, { key: secretTreeItem.secret.key, value: newValue, selected: secretTreeItem.secret.selected }, StorageKey.Secrets);
+                    this.refresh();
+                }
             }),
             commands.registerCommand('githubLocalActions.editVariable', async (variableTreeItem: VariableTreeItem) => {
-                //TODO: Implement
+                const newValue = await window.showInputBox({
+                    prompt: `Enter the value for ${variableTreeItem.variable.value}`,
+                    placeHolder: `Variable value`,
+                    value: variableTreeItem.variable.value
+                });
+
+                if (newValue) {
+                    act.settingsManager.editSetting(variableTreeItem.workspaceFolder, { key: variableTreeItem.variable.key, value: newValue, selected: variableTreeItem.variable.selected }, StorageKey.Variables);
+                    this.refresh();
+                }
             }),
             commands.registerCommand('githubLocalActions.editInput', async (inputTreeItem: InputTreeItem) => {
-                //TODO: Implement
+                const newValue = await window.showInputBox({
+                    prompt: `Enter the value for ${inputTreeItem.input.value}`,
+                    placeHolder: `Input value`,
+                    value: inputTreeItem.input.value
+                });
+
+                if (newValue) {
+                    act.settingsManager.editSetting(inputTreeItem.workspaceFolder, { key: inputTreeItem.input.key, value: newValue, selected: inputTreeItem.input.selected }, StorageKey.Inputs);
+                    this.refresh();
+                }
             }),
             commands.registerCommand('githubLocalActions.addRunner', async (runnersTreeItem: RunnersTreeItem) => {
                 //TODO: Implement
-            }),
-            commands.registerCommand('githubLocalActions.editContainerEngine', async (containerEngineTreeItem: ContainerEngineTreeItem) => {
-                //TODO: Implement
             })
         );
     }
@@ -62,7 +87,7 @@ export default class SettingsTreeDataProvider implements TreeDataProvider<Github
             const workspaceFolders = workspace.workspaceFolders;
             if (workspaceFolders) {
                 if (workspaceFolders.length === 1) {
-                    return await new WorkspaceFolderSettingsTreeItem(workspaceFolders[0]).getChildren();
+                    items.push(...await new WorkspaceFolderSettingsTreeItem(workspaceFolders[0]).getChildren());
                 } else if (workspaceFolders.length > 1) {
                     for (const workspaceFolder of workspaceFolders) {
                         items.push(new WorkspaceFolderSettingsTreeItem(workspaceFolder));

src/views/settings/variable.ts

@@ -4,13 +4,15 @@ import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
 
 export default class VariableTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
     static contextValue = 'githubLocalActions.variable';
+    variable: Variable;
 
     constructor(public workspaceFolder: WorkspaceFolder, variable: Variable) {
         super(variable.key, TreeItemCollapsibleState.None);
+        this.variable = variable;
         this.description = variable.value;
         this.contextValue = VariableTreeItem.contextValue;
         this.iconPath = new ThemeIcon('symbol-variable');
-        this.checkboxState = TreeItemCheckboxState.Unchecked;
+        this.checkboxState = variable.selected ? TreeItemCheckboxState.Checked : TreeItemCheckboxState.Unchecked;
     }
 
     async getChildren(): Promise<GithubLocalActionsTreeItem[]> {

src/views/settings/variables.ts

@@ -2,6 +2,7 @@ import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "
 import { act } from "../../extension";
 import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
 import VariableTreeItem from "./variable";
+import { StorageKey } from "../../storageManager";
 
 export default class VariablesTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
     static contextValue = 'githubLocalActions.variables';
@@ -13,8 +14,13 @@ export default class VariablesTreeItem extends TreeItem implements GithubLocalAc
     }
 
     async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
-        const workflows = await act.workflowsManager.getWorkflows(this.workspaceFolder);
+        const items: GithubLocalActionsTreeItem[] = [];
-        const variables = [...new Set(workflows.map(workflow => act.settingsManager.getVariables(workflow)).flat())];
+
-        return variables.map(variable => new VariableTreeItem(this.workspaceFolder, variable));
+        const variables = await act.settingsManager.getSetting(this.workspaceFolder, /\${{\s*vars\.(.*?)(?:\s*==\s*(.*?))?\s*}}/g, StorageKey.Variables);
+        for (const variable of variables) {
+            items.push(new VariableTreeItem(this.workspaceFolder, variable));
+        }
+
+        return items;
     }
 }

src/views/settings/workspaceFolderSettings.ts

@@ -1,6 +1,5 @@
 import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
 import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
-import ContainerEnginesTreeItem from "./containerEngines";
 import EnvironmentsTreeItem from "./environments";
 import InputsTreeItem from "./inputs";
 import RunnersTreeItem from "./runners";
@@ -24,8 +23,7 @@ export default class WorkspaceFolderSettingsTreeItem extends TreeItem implements
             new SecretsTreeItem(this.workspaceFolder),
             new VariablesTreeItem(this.workspaceFolder),
             new InputsTreeItem(this.workspaceFolder),
-            new RunnersTreeItem(this.workspaceFolder),
+            new RunnersTreeItem(this.workspaceFolder)
-            new ContainerEnginesTreeItem(this.workspaceFolder)
         ]);
 
         return items;

src/views/workflows/workflowsTreeDataProvider.ts

@@ -75,7 +75,7 @@ export default class WorkflowsTreeDataProvider implements TreeDataProvider<Githu
             const workspaceFolders = workspace.workspaceFolders;
             if (workspaceFolders) {
                 if (workspaceFolders.length === 1) {
-                    return await new WorkspaceFolderWorkflowsTreeItem(workspaceFolders[0]).getChildren();
+                    items.push(...await new WorkspaceFolderWorkflowsTreeItem(workspaceFolders[0]).getChildren());
                 } else if (workspaceFolders.length > 1) {
                     for (const workspaceFolder of workspaceFolders) {
                         items.push(new WorkspaceFolderWorkflowsTreeItem(workspaceFolder));