sparrow-cli 0.5.4

A local-first Rust agent cockpit — route, run, replay, rewind
Documentation 
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

// Sparrow VS Code extension — thin wrapper that drives the existing
// WebView cockpit running locally and exposes Sparrow's CLI as commands.

const vscode = require("vscode");
const { spawn } = require("child_process");
const http = require("http");

let cockpitProcess = null;

function activate(context) {
    const config = () => vscode.workspace.getConfiguration("sparrow");

    const ensureCockpit = async () => {
        const port = config().get("cockpitPort", 9339);
        const reachable = await pingCockpit(port);
        if (reachable) return port;

        const bin = config().get("binaryPath", "sparrow");
        cockpitProcess = spawn(bin, ["console", "--port", String(port)], {
            detached: false,
            stdio: "ignore",
        });
        cockpitProcess.on("exit", () => {
            cockpitProcess = null;
        });

        // Wait up to 5 seconds for the cockpit to come online.
        for (let i = 0; i < 25; i++) {
            await new Promise((r) => setTimeout(r, 200));
            if (await pingCockpit(port)) return port;
        }
        throw new Error("Sparrow cockpit did not respond on port " + port);
    };

    context.subscriptions.push(
        vscode.commands.registerCommand("sparrow.openCockpit", async () => {
            try {
                const port = await ensureCockpit();
                const panel = vscode.window.createWebviewPanel(
                    "sparrowCockpit",
                    "Sparrow Cockpit",
                    vscode.ViewColumn.Beside,
                    { enableScripts: true, retainContextWhenHidden: true }
                );
                panel.webview.html = cockpitHtml(port);
            } catch (e) {
                vscode.window.showErrorMessage("Sparrow: " + e.message);
            }
        }),

        vscode.commands.registerCommand("sparrow.run", async () => {
            const task = await vscode.window.showInputBox({
                prompt: "Sparrow — task to run",
                placeHolder: "e.g. add a unit test for the login function",
            });
            if (!task) return;
            const term = vscode.window.createTerminal({ name: "Sparrow" });
            term.show();
            term.sendText(`${config().get("binaryPath", "sparrow")} run "${task.replace(/"/g, '\\"')}"`);
        }),

        vscode.commands.registerCommand("sparrow.plan", async () => {
            const task = await vscode.window.showInputBox({
                prompt: "Sparrow — task to plan (read-only)",
                placeHolder: "e.g. refactor the auth module",
            });
            if (!task) return;
            const term = vscode.window.createTerminal({ name: "Sparrow plan" });
            term.show();
            term.sendText(`${config().get("binaryPath", "sparrow")} plan "${task.replace(/"/g, '\\"')}"`);
        }),

        vscode.commands.registerCommand("sparrow.rewind", () => {
            const term = vscode.window.createTerminal({ name: "Sparrow rewind" });
            term.show();
            term.sendText(`${config().get("binaryPath", "sparrow")} rewind --last`);
        })
    );

    if (config().get("autoLaunchCockpit", false)) {
        ensureCockpit().catch(() => undefined);
    }
}

function pingCockpit(port) {
    return new Promise((resolve) => {
        const req = http.get(
            { host: "127.0.0.1", port, path: "/healthz", timeout: 250 },
            (res) => {
                resolve(res.statusCode === 200);
                res.resume();
            }
        );
        req.on("error", () => resolve(false));
        req.on("timeout", () => {
            req.destroy();
            resolve(false);
        });
    });
}

function cockpitHtml(port) {
    return `<!doctype html><html><head><meta charset="utf-8" />
<style>html,body,iframe{margin:0;padding:0;border:0;width:100%;height:100vh;}</style>
</head><body>
<iframe src="http://127.0.0.1:${port}/" allow="clipboard-read; clipboard-write"></iframe>
</body></html>`;
}

function deactivate() {
    if (cockpitProcess) {
        try {
            cockpitProcess.kill();
        } catch (_) {}
    }
}

module.exports = { activate, deactivate };