vtcode 0.172.2

A Rust-based terminal coding agent with modular architecture supporting multiple LLM providers
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

const { test, beforeEach, afterEach } = require("node:test");
const assert = require("node:assert/strict");
const compileModules = require("./helpers/compileModules.cjs");
const { load, vscode } = compileModules([
    "services/workspaceTrust", "commands/trustWorkspaceCommand", "types/command", "commandRegistry",
]);
const { requestWorkspaceTrust } = load("services/workspaceTrust");
const { TrustWorkspaceCommand } = load("commands/trustWorkspaceCommand");
const { CommandRegistry } = load("commandRegistry");
const { BaseCommand } = load("types/command");
let proposalReads;

beforeEach(() => {
    vscode.workspace.isTrusted = false;
    vscode.testState.handlers.clear();
    vscode.testState.messages.length = 0;
    proposalReads = 0;
    Object.defineProperty(vscode.workspace, "requestWorkspaceTrust", {
        configurable: true,
        get() {
            proposalReads += 1;
            throw new Error("workspaceTrust API proposal is unavailable");
        },
    });
});
afterEach(() => {
    assert.equal(proposalReads, 0, "stable trust flows must never access the proposed API");
    delete vscode.workspace.requestWorkspaceTrust;
});

test("already trusted workspaces return without prompting or managing trust", async (t) => {
    vscode.workspace.isTrusted = true;
    const warning = t.mock.method(vscode.window, "showWarningMessage");
    const info = t.mock.method(vscode.window, "showInformationMessage");
    const manage = t.mock.method(vscode.commands, "executeCommand");
    assert.equal(await requestWorkspaceTrust("unused", "warning"), true);
    assert.equal(warning.mock.callCount(), 0);
    assert.equal(info.mock.callCount(), 0);
    assert.equal(manage.mock.callCount(), 0);
});

test("warning flow uses stable management and accepts only the host's granted state", async (t) => {
    const prompts = [];
    const commands = [];
    t.mock.method(vscode.window, "showWarningMessage", async (...args) => {
        prompts.push(args);
        return "Manage Workspace Trust";
    });
    t.mock.method(vscode.commands, "executeCommand", async (...args) => {
        commands.push(args);
        vscode.workspace.isTrusted = true;
    });
    const message = "Trust required to run a literal ; $(action).";
    assert.equal(await requestWorkspaceTrust(message, "warning"), true);
    assert.deepEqual(prompts, [[message, "Manage Workspace Trust"]]);
    assert.deepEqual(commands, [["workbench.action.manageTrust"]]);
});

test("opening management without granting trust remains denied", async (t) => {
    t.mock.method(vscode.window, "showInformationMessage", async () => "Manage Workspace Trust");
    const manage = t.mock.method(vscode.commands, "executeCommand", async () => true);
    assert.equal(await requestWorkspaceTrust("Review trust", "information"), false);
    assert.equal(manage.mock.callCount(), 1);
    assert.equal(vscode.workspace.isTrusted, false);
});

test("dismissed prompts neither open management nor grant trust", async (t) => {
    t.mock.method(vscode.window, "showInformationMessage", async () => undefined);
    const manage = t.mock.method(vscode.commands, "executeCommand");
    assert.equal(await requestWorkspaceTrust("Review trust", "information"), false);
    assert.equal(manage.mock.callCount(), 0);
});

test("trust is re-read after awaiting management rather than cached before it", async (t) => {
    let finish;
    t.mock.method(vscode.window, "showWarningMessage", async () => "Manage Workspace Trust");
    t.mock.method(vscode.commands, "executeCommand", () => new Promise((resolve) => { finish = resolve; }));
    const pending = requestWorkspaceTrust("Trust before execution", "warning");
    await Promise.resolve();
    assert.equal(typeof finish, "function");
    assert.equal(vscode.workspace.isTrusted, false);
    vscode.workspace.isTrusted = true;
    finish();
    assert.equal(await pending, true);
});

test("prompt and management failures propagate with their original identity", async (t) => {
    const promptFailure = new Error("Prompt unavailable");
    const manageFailure = new Error("Management unavailable");
    const prompt = t.mock.method(vscode.window, "showWarningMessage", async () => { throw promptFailure; });
    const manage = t.mock.method(vscode.commands, "executeCommand", async () => { throw manageFailure; });
    await assert.rejects(requestWorkspaceTrust("Trust required", "warning"), (error) => error === promptFailure);
    assert.equal(manage.mock.callCount(), 0);
    prompt.mock.mockImplementation(async () => "Manage Workspace Trust");
    await assert.rejects(requestWorkspaceTrust("Trust required", "warning"), (error) => error === manageFailure);
    assert.equal(vscode.workspace.isTrusted, false);
});

test("registered trust command is available while execution commands stay blocked", async (t) => {
    let runs = 0;
    class ExecutionCommand extends BaseCommand {
        id = "fixture.execute";
        title = "Execution fixture";
        async execute() { runs += 1; }
    }
    t.mock.method(vscode.window, "showInformationMessage", async (message) => {
        vscode.testState.messages.push(message);
        return "Manage Workspace Trust";
    });
    const management = [];
    vscode.testState.handlers.set("workbench.action.manageTrust", () => {
        management.push("opened");
        vscode.workspace.isTrusted = true;
    });
    const registry = new CommandRegistry();
    t.after(() => registry.dispose());
    registry.registerAll([new TrustWorkspaceCommand(), new ExecutionCommand()]);
    await vscode.testState.handlers.get("fixture.execute")();
    assert.equal(runs, 0);
    await vscode.testState.handlers.get("vtcode.trustWorkspace")();
    assert.deepEqual(management, ["opened"]);
    assert.equal(vscode.workspace.isTrusted, true);
    assert.match(vscode.testState.messages.at(-1), /Workspace trust granted/);
    assert.equal(runs, 0);
});

test("registered trust command does not claim a grant after dismissal", async (t) => {
    const registry = new CommandRegistry();
    t.after(() => registry.dispose());
    registry.register(new TrustWorkspaceCommand());
    await vscode.testState.handlers.get("vtcode.trustWorkspace")();
    assert.equal(vscode.workspace.isTrusted, false);
    assert.equal(vscode.testState.messages.length, 1);
    assert.match(vscode.testState.messages[0], /Workspace trust is still required/);
    assert.doesNotMatch(vscode.testState.messages[0], /granted/);
});