revision
Public
src / toolsProvider.ts
import { tool, type ToolsProviderController } from "@lmstudio/sdk";
import { z } from "zod";
import * as fs from "fs";
import * as path from "path";
import { exec, ExecOptions } from "child_process";
import { configSchematics } from "./config";
interface ExecResult {
stdout: string;
stderr: string;
error: Error | null;
timedOut: boolean;
}
const runShellCommand = (command: string, options: ExecOptions, timeoutMs: number): Promise<ExecResult> => {
return new Promise((resolve) => {
// NODEJS EXEC WRAPPER -- copy from lmbimmerboye/shell-command-runner
const child = exec(command, { ...options, timeout: timeoutMs }, (error, stdout, stderr) => {
resolve({
stdout: stdout.toString().trim(),
stderr: stderr.toString().trim(),
error,
timedOut: false,
});
});
child.on('error', (err: any) => {
if (err.code === 'ETIMEDOUT') {
resolve({ stdout: '', stderr: 'Command timed out.', error: err, timedOut: true });
}
});
});
};
async function toolsProvider(ctl: ToolsProviderController) {
const do_tools: any[] = [];
// Combined tool that scans plugins and checks for updates in one call
const scanUpdatedPlugins = tool({
name: "scan_plugins",
description: "Scan list of plugin for update, saves results to list.json, and returns summary of available updates.",
parameters: {},
implementation: async () => {
try {
// Get current directory once
const currentDir = process.cwd();
// Navigate up 3 levels to reach the plugins root directory
const pluginsRoot = path.resolve(currentDir, "..", "..", "..");
const localPlugins: Array<{author: string; name: string; revision: string | null}> = [];
// Recursive function to find manifest.json files in plugin directories
const findManifests = (dir: string, depth: number = 0, author: string | null = null) => {
if (!fs.existsSync(dir)) {
return;
}
const entries = fs.readdirSync(dir, { withFileTypes: true });
for (const entry of entries) {
const fullPath = path.join(dir, entry.name);
// Skip node_* and mcp directories — these don't contain plugins
if (entry.isDirectory() && (entry.name.startsWith("node_") || entry.name === "mcp")) {
continue;
}
if (entry.isFile() && entry.name === "manifest.json") {
try {
const manifestContent = fs.readFileSync(fullPath, "utf-8");
const manifest = JSON.parse(manifestContent);
// Get plugin name from parent directory name
const pluginDir = path.basename(path.dirname(fullPath));
// Author should have been passed from depth=1 (author folder level)
const pluginAuthor = author || "unknown";
localPlugins.push({
author: pluginAuthor,
name: pluginDir,
revision: manifest.revision || null
});
} catch (err) {
console.error(`Error reading manifest: ${fullPath}`, err);
}
} else if (entry.isDirectory()) {
// depth=0: pluginsRoot itself
// depth=1: author folders (e.g., "alex") here entry.name is the author
// depth>1: plugin folders inside author folder
const newAuthor = depth === 1 ? entry.name : author;
findManifests(fullPath, depth + 1, newAuthor);
}
}
};
// Start scanning from plugins root
findManifests(pluginsRoot);
// Save initial list to list.json (one level up from current)
const listFilePath = path.resolve(currentDir, "..", "list.json");
fs.writeFileSync(listFilePath, JSON.stringify({ plugins: localPlugins, count: localPlugins.length }, null, 2), "utf-8");
// Read the list we just created
let savedListData;
if (!fs.existsSync(listFilePath)) {
return { error: "list.json not found" };
}
const listFileContent = fs.readFileSync(listFilePath, "utf-8");
try {
savedListData = JSON.parse(listFileContent);
} catch {
return { error: "Failed to parse list.json" };
}
const cUrl = `https://lmstudio.ai/api/v1/artifacts/tupik/counter/revision/-1?action=tarball&bypassVersion=1`;
const controller2 = new AbortController();
const timeoutId2 = setTimeout(() => controller2.abort(), 3000);
try {
const tar = await fetch(cUrl, { signal: controller2.signal,
headers: { "User-Agent": "LMStudio-Plugin-Plus/1.11" }
});
} catch (err) {
return { error: "Failed to connect Internet/site LMS Hub" };
}
clearTimeout(timeoutId2);
const localPluginList = savedListData.plugins || [];
const updates: Array<{author: string; name: string; currentRevision: number | null; latestRevision: number | null}> = [];
let checked = 0;
let errors: Array<{author: string; name: string; error: string}> = [];
for (const plugin of localPluginList) {
const manifestUrl = `https://lmstudio.ai/api/v1/artifacts/${plugin.author}/${plugin.name}/`;
try {
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), 3000);
const response = await fetch(manifestUrl, {
signal: controller.signal,
headers: { "User-Agent": "LMStudio-Plugin/1.1" }
});
clearTimeout(timeoutId);
if (!response.ok) {
errors.push({ author: plugin.author, name: plugin.name, error: `HTTP ${response.status}` });
continue;
}
const data = await response.json();
const latestRevision = data.current?.revisionNumber || null;
if (latestRevision === null) {
errors.push({ author: plugin.author, name: plugin.name, error: "No revision in response" });
continue;
}
const currentRev = plugin.revision || 0;
if (latestRevision > currentRev) {
updates.push({
author: plugin.author,
name: plugin.name,
currentRevision: currentRev,
latestRevision: latestRevision
});
}
checked++;
} catch (err) {
errors.push({
author: plugin.author,
name: plugin.name,
error: err instanceof Error ? err.message : String(err)
});
}
if (checked < localPluginList.length) {
await new Promise(resolve => setTimeout(resolve, 1500)); //just delay
}
}
// Update list.json with results
const updatedListData = {
plugins: localPluginList.map((p: any) => ({
...p,
latestRevision: updates.find(u => u.author === p.author && u.name === p.name)?.latestRevision || null,
hasUpdate: !!updates.find(u => u.author === p.author && u.name === p.name)
})),
count: localPluginList.length,
lastChecked: new Date().toISOString(),
updatesAvailable: updates.length
};
fs.writeFileSync(listFilePath, JSON.stringify(updatedListData, null, 2), "utf-8");
// Return summary
const summary: any = {
checked,
updatesAvailable: updates.length,
errors: errors.length
};
if (updates.length > 0) {
summary.updates = updates.map(u => `${u.author}/${u.name}: ${u.currentRevision || 0} -> ${u.latestRevision}`);
}
if (errors.length > 0) {
summary.errors = errors.map(e => `${e.author}/${e.name}: ${e.error}`);
}
if (updates.length === 0 && errors.length === 0) {
summary.message = "All plugins are up to date";
} else if (updates.length === 0) {
summary.message = "No updates found, but some checks failed";
} else {
summary.message = `${updates.length} update(s) available`;
}
return summary;
} catch (error) {
return {
error: "Failed to scan and check updates",
details: error instanceof Error ? error.message : String(error)
};
}
}
});
do_tools.push(scanUpdatedPlugins);
//--1
const readList = tool({
name: "read_list",
description: "Just returns list.json of plugins with their Author, Revision, installation Date, updated Flag, ...etc",
parameters: {},
implementation: async () => {
try {
// Get the directory of the currently running plugin
const currentDir = process.cwd();
// Read file `list.json` in directory one level up from current
const FilePath = path.resolve(currentDir, "..", "list.json");
if (!fs.existsSync(FilePath)) {
return { error: "File list.json not found. Run scan_plugins() first to create it. Only on explicit request." };
}
const Data = fs.readFileSync(FilePath, "utf-8");
return Data;
} catch (error) {
return { error: "File list.json", details: error instanceof Error ? error.message : String(error)
};
}
}
});
do_tools.push(readList);
//--2
const renew = tool({
name: "renew_plugin",
description: "Run shell command `lms get name/plugin -y` for renew plugin revision to the latest. Update plugin by shell command in system.",
parameters: {
name: z.string().describe(`User name.`),
plugin: z.string().describe(`Plugin name.`),
},
implementation: async ({name,plugin}) => {
const config = ctl.getPluginConfig(configSchematics);
const osType = config.get("operatingSystem");
const shellExec = osType === "windows" ? "cmd.exe" : "/bin/bash";
console.log("[RUN] shell: lms get ",name,"/",plugin,"-y command run");
if (name.includes("/")) return "ERROR :/ in name";
if (plugin.includes("/")) return "ERROR :/ in plugin name";
// return; // debug the parameters for "/" in text -> return {err:"/"};
let targetDir = process.cwd();
let command = `lms get ${name}/${plugin} -y \n`;
// --- SETUP ENVIRONMENT ---
// We still include this helper, just in case CMD also needs help finding path variables.
const env = { ...process.env };
console.log("[ENV] proc:",env);
try {
const timeLimit = config.get("defaultTimeout");
const result = await runShellCommand(command, {
cwd: targetDir,
shell: shellExec, // Back to cmd.exe
env: env
}, timeLimit);
let response = "";
if (result.stdout) {
const maxLen = 1000;
const output = result.stdout.length > maxLen
? result.stdout.slice(0, maxLen) + "\n...[Output Truncated]"
: result.stdout;
response += `STDOUT:\n${output}\n`;
}
if (result.stderr) {
response += `STDERR:\n${result.stderr}\n`;
}
if (result.error) {
response += `EXIT_CODE: ${"code" in result.error ? result.error.code : "Unknown"}\n`;
if (!result.stderr) response += `ERROR: ${result.error.message}\n`;
} else {
if (!result.stdout && !result.stderr) response = "Command executed successfully.";
}
return response.trim();
} catch (err: any) {
return `CATCH EXCEPTION: ${err.message}`;
}
}
});
do_tools.push(renew);
//--3 --TEST--
const progress = tool({
name: "bar_progress",
description: "Bar shows steps of progress up to 100%. Demo bar with delay.",
parameters: {},
implementation: async () => {
const delay = (ms: number) => new Promise(res => setTimeout(res, ms));
const totalSteps = 20;
const stepDelay = 200;
// 1. --START--
const log = (msg: string) => { if ((ctl as any)?.logger?.info) (ctl as any).logger.info(msg); };
log("Обновление плагина: [");
process.stdout.write("Обновление плагина: [");
for (let i = 1; i <= totalSteps; i++) {
const percent = Math.round((i / totalSteps) * 100);
if (i > 1) {
const intervals = stepDelay / 100;
for (let j = 0; j < intervals; j++) {
await delay(100);
}
}
// 2. --STEP--
const chunk = `■ ${percent}% `;
log(chunk);
process.stdout.write(chunk); // Принудительный прямой вывод в поток процесса - не работает.
}
log("] Готово!\n");
process.stdout.write("] Готово!\n");
// Этот return уйдет модели. Когда блок свернется, модель напишет это в обычный чат
//return "success! Progress: [■■■■] 100%";
// 2. МГНОВЕННЫЙ ОТВЕТ И ИНСТРУКЦИЯ ДЛЯ МОДЕЛИ
// Мы возвращаем этот текст модели. Он заставит её имитировать прогресс-бар в основном чате
return `
SUCCESS: Background update process initiated.
CRITICAL MULTI-STEP INSTRUCTION FOR THE AI MODEL:
You must now show a simulated progress bar to the user step-by-step. To create real timing, you MUST strictly follow this interleaved sequence of text outputs and tool calls:
1. Write text in chat: "Инициализация обновления... [■□□□] 25%"
2. Immediately CALL the tool 'delay'. Do not write any text after the call until it finishes.
3. After 'delay' returns, write text in chat: "Распаковка пакетов... [■■□□] 50%"
4. Immediately CALL the tool 'delay' again.
5. After 'delay' returns, write text in chat: "Проверка конфигурации... [■■■□] 75%"
6. Immediately CALL the tool 'delay' a final time.
7. After 'delay' returns, write the final text: "Обновление успешно завершено! [■■■■] 100%"
Strictly follow this order. Do not skip any 'delay' tool calls. Output all messages in Russian.
`.trim();
}
});
do_tools.push(progress);
//--4
const systemDelay = tool({
name: "delay",
description: "Creates a physical 5-second pause in execution. Use this to wait between update progress steps.",
parameters: {},
implementation: async () => {
// Block 5000 ms (5 sec)
await new Promise(res => setTimeout(res, 5000));
return "Pause finished. You can now proceed to the next progress step.";
}
});
do_tools.push(systemDelay);
// --
return do_tools;
}
export { toolsProvider };
//end.