a6b866e279
Source commit: 5792a1a4e1cb24ff71b1535d4b582ef980880752 Public tree identity: sha256:eea1f740446827ef10e4892923c13f13077c9e03438f2bf53d7f90536fb4cf95
730 lines
23 KiB
JavaScript
730 lines
23 KiB
JavaScript
const fs = require("fs");
|
|
const path = require("path");
|
|
const childProcess = require("child_process");
|
|
const crypto = require("crypto");
|
|
|
|
|
|
let vscode = null;
|
|
try {
|
|
vscode = require("vscode");
|
|
} catch (_) {
|
|
vscode = null;
|
|
}
|
|
|
|
function discoverEnvironmentNames(projectRoot) {
|
|
const envsDir = path.join(projectRoot, "envs");
|
|
if (!fs.existsSync(envsDir)) return [];
|
|
|
|
return fs
|
|
.readdirSync(envsDir, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory())
|
|
.map((entry) => entry.name)
|
|
.filter((name) => {
|
|
const dir = path.join(envsDir, name);
|
|
return (
|
|
fs.existsSync(path.join(dir, "Containerfile")) ||
|
|
fs.existsSync(path.join(dir, "Dockerfile"))
|
|
);
|
|
})
|
|
.sort();
|
|
}
|
|
|
|
function findEnvReferences(text) {
|
|
const references = [];
|
|
const pattern = /env!\(\s*"([^"]+)"\s*\)/g;
|
|
let match;
|
|
while ((match = pattern.exec(text)) !== null) {
|
|
references.push({
|
|
name: match[1],
|
|
start: match.index,
|
|
end: pattern.lastIndex
|
|
});
|
|
}
|
|
return references;
|
|
}
|
|
|
|
function diagnoseEnvReferences(text, environmentNames) {
|
|
const known = new Set(environmentNames);
|
|
return findEnvReferences(text)
|
|
.filter((reference) => !known.has(reference.name))
|
|
.map((reference) => ({
|
|
...reference,
|
|
message: `Missing Clusterflux environment "${reference.name}". Add envs/${reference.name}/Containerfile or envs/${reference.name}/Dockerfile.`
|
|
}));
|
|
}
|
|
|
|
function binaryCandidates(projectRoot, name) {
|
|
const names = process.platform === "win32" ? [name, `${name}.exe`] : [name];
|
|
return names.map((candidate) => path.join(projectRoot, candidate));
|
|
}
|
|
|
|
function executableWorkspaceBinary(projectRoot, name) {
|
|
if (!projectRoot) return null;
|
|
return binaryCandidates(projectRoot, name).find((candidate) => {
|
|
try {
|
|
return fs.statSync(candidate).isFile();
|
|
} catch (_) {
|
|
return false;
|
|
}
|
|
}) || null;
|
|
}
|
|
|
|
function hasCargoWorkspace(root) {
|
|
return fs.existsSync(path.join(root, "Cargo.toml"));
|
|
}
|
|
|
|
function resolveProjectPath(folder, value) {
|
|
const workspaceRoot = folder && folder.uri && folder.uri.fsPath;
|
|
if (!value || value === "${workspaceFolder}") return workspaceRoot;
|
|
if (workspaceRoot && typeof value === "string") {
|
|
return value.replace(/\$\{workspaceFolder\}/g, workspaceRoot);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function bundleInspectCommand(projectRoot, adapterWorkspace = path.resolve(__dirname, "..")) {
|
|
const workspaceCli = executableWorkspaceBinary(projectRoot, "clusterflux");
|
|
if (workspaceCli) {
|
|
return {
|
|
command: workspaceCli,
|
|
args: ["bundle", "inspect", "--project", projectRoot, "--json"],
|
|
options: {
|
|
cwd: projectRoot,
|
|
encoding: "utf8"
|
|
}
|
|
};
|
|
}
|
|
|
|
return {
|
|
command: "cargo",
|
|
args: [
|
|
"run",
|
|
"-q",
|
|
"-p",
|
|
"clusterflux-cli",
|
|
"--bin",
|
|
"clusterflux",
|
|
"--",
|
|
"bundle",
|
|
"inspect",
|
|
"--project",
|
|
projectRoot,
|
|
"--json"
|
|
],
|
|
options: {
|
|
cwd: adapterWorkspace,
|
|
encoding: "utf8"
|
|
}
|
|
};
|
|
}
|
|
|
|
function clusterfluxCliCommand(
|
|
projectRoot,
|
|
args,
|
|
adapterWorkspace = path.resolve(__dirname, "..")
|
|
) {
|
|
const workspaceCli = executableWorkspaceBinary(projectRoot, "clusterflux");
|
|
if (workspaceCli) {
|
|
return {
|
|
command: workspaceCli,
|
|
args,
|
|
options: { cwd: projectRoot, encoding: "utf8" }
|
|
};
|
|
}
|
|
if (!hasCargoWorkspace(adapterWorkspace)) {
|
|
return {
|
|
command: "clusterflux",
|
|
args,
|
|
options: { cwd: projectRoot, encoding: "utf8" }
|
|
};
|
|
}
|
|
return {
|
|
command: "cargo",
|
|
args: ["run", "-q", "-p", "clusterflux-cli", "--bin", "clusterflux", "--", ...args],
|
|
options: { cwd: adapterWorkspace, encoding: "utf8" }
|
|
};
|
|
}
|
|
|
|
function runClusterfluxCliJson(
|
|
projectRoot,
|
|
args,
|
|
adapterWorkspace = path.resolve(__dirname, ".."),
|
|
runner = childProcess.spawnSync
|
|
) {
|
|
const invocation = clusterfluxCliCommand(projectRoot, [...args, "--json"], adapterWorkspace);
|
|
const result = runner(invocation.command, invocation.args, invocation.options);
|
|
if (result.error) {
|
|
throw new Error(`Clusterflux CLI failed: ${result.error.message}`);
|
|
}
|
|
if (result.status !== 0) {
|
|
const detail = String(result.stderr || result.stdout || "").trim();
|
|
throw new Error(detail || `Clusterflux CLI exited with status ${result.status}`);
|
|
}
|
|
try {
|
|
return JSON.parse(result.stdout);
|
|
} catch (error) {
|
|
throw new Error(`Clusterflux CLI returned invalid JSON: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
function loadLiveProcesses(
|
|
projectRoot,
|
|
adapterWorkspace = path.resolve(__dirname, ".."),
|
|
runner = childProcess.spawnSync
|
|
) {
|
|
try {
|
|
const report = runClusterfluxCliJson(
|
|
projectRoot,
|
|
["process", "list"],
|
|
adapterWorkspace,
|
|
runner
|
|
);
|
|
return {
|
|
processes: asArray(report.processes),
|
|
coordinator: report.coordinator || null,
|
|
tenant: report.tenant || null,
|
|
project: report.project || null,
|
|
user: report.user || null,
|
|
error: null
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
processes: [],
|
|
coordinator: null,
|
|
tenant: null,
|
|
project: null,
|
|
user: null,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
function digestFromParts(parts) {
|
|
const hasher = crypto.createHash("sha256");
|
|
for (const value of parts) {
|
|
const part = Buffer.from(value);
|
|
const length = Buffer.alloc(8);
|
|
length.writeBigUInt64BE(BigInt(part.length));
|
|
hasher.update(length);
|
|
hasher.update(part);
|
|
}
|
|
return hasher.digest("hex");
|
|
}
|
|
|
|
function clusterfluxProcessId(projectRoot, entry = "build") {
|
|
return `vp-${digestFromParts(["dap-process:v1", projectRoot, entry]).slice(0, 12)}`;
|
|
}
|
|
|
|
function refreshBundleBeforeLaunch(
|
|
projectRoot,
|
|
adapterWorkspace = path.resolve(__dirname, ".."),
|
|
runner = childProcess.spawnSync
|
|
) {
|
|
const command = bundleInspectCommand(projectRoot, adapterWorkspace);
|
|
const result = runner(command.command, command.args, command.options);
|
|
if (result.error) {
|
|
throw new Error(`Clusterflux bundle refresh failed: ${result.error.message}`);
|
|
}
|
|
if (result.status !== 0) {
|
|
const detail = (result.stderr || result.stdout || "").trim();
|
|
throw new Error(
|
|
`Clusterflux bundle refresh failed before debug launch${detail ? `: ${detail}` : "."}`
|
|
);
|
|
}
|
|
|
|
let inspection;
|
|
try {
|
|
inspection = JSON.parse(result.stdout);
|
|
} catch (error) {
|
|
throw new Error(`Clusterflux bundle refresh returned invalid metadata: ${error.message}`);
|
|
}
|
|
if (!inspection.metadata || !inspection.metadata.identity) {
|
|
throw new Error("Clusterflux bundle refresh did not return a bundle identity.");
|
|
}
|
|
return inspection;
|
|
}
|
|
|
|
function clusterfluxViewDescriptors() {
|
|
return [
|
|
{ id: "clusterflux.nodes", emptyLabel: "No attached nodes" },
|
|
{ id: "clusterflux.processes", emptyLabel: "No virtual processes" },
|
|
{ id: "clusterflux.logs", emptyLabel: "No log streams" },
|
|
{ id: "clusterflux.artifacts", emptyLabel: "No artifacts" },
|
|
{ id: "clusterflux.inspector", emptyLabel: "No inspector state" }
|
|
];
|
|
}
|
|
|
|
function clusterfluxViewStatePath(projectRoot) {
|
|
return path.join(projectRoot, ".clusterflux", "views.json");
|
|
}
|
|
|
|
function emptyClusterfluxViewState() {
|
|
return {
|
|
nodes: [],
|
|
processes: [],
|
|
logs: [],
|
|
artifacts: [],
|
|
inspector: []
|
|
};
|
|
}
|
|
|
|
function asArray(value) {
|
|
return Array.isArray(value) ? value : [];
|
|
}
|
|
|
|
function loadClusterfluxViewState(projectRoot, reader = fs.readFileSync) {
|
|
const statePath = clusterfluxViewStatePath(projectRoot);
|
|
if (!fs.existsSync(statePath)) {
|
|
return emptyClusterfluxViewState();
|
|
}
|
|
|
|
let parsed;
|
|
try {
|
|
parsed = JSON.parse(reader(statePath, "utf8"));
|
|
} catch (error) {
|
|
return {
|
|
...emptyClusterfluxViewState(),
|
|
inspector: [
|
|
{
|
|
label: "View state error",
|
|
value: error.message
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
return {
|
|
nodes: asArray(parsed.nodes),
|
|
processes: asArray(parsed.processes),
|
|
logs: asArray(parsed.logs),
|
|
artifacts: asArray(parsed.artifacts),
|
|
inspector: asArray(parsed.inspector)
|
|
};
|
|
}
|
|
|
|
function item(label, description = "", options = {}) {
|
|
return {
|
|
label: String(label || ""),
|
|
description: String(description || ""),
|
|
...options
|
|
};
|
|
}
|
|
|
|
function clusterfluxViewItems(state, viewId) {
|
|
switch (viewId) {
|
|
case "clusterflux.nodes":
|
|
return state.nodes.map((node) =>
|
|
item(node.id || node.name || "node", [node.status, node.capabilities].filter(Boolean).join(" "))
|
|
);
|
|
case "clusterflux.processes":
|
|
return state.processes.map((process) =>
|
|
item(
|
|
process.id || process.process || "process",
|
|
[process.state || process.status, process.entry].filter(Boolean).join(" "),
|
|
{
|
|
processId: process.id || process.process,
|
|
processState: process.state || process.status || "unknown",
|
|
contextValue: "clusterflux.virtualProcess",
|
|
command: {
|
|
command: "clusterflux.process.attach",
|
|
title: "Attach to Virtual Process",
|
|
arguments: [process.id || process.process]
|
|
}
|
|
}
|
|
)
|
|
);
|
|
case "clusterflux.logs":
|
|
return state.logs.map((log) =>
|
|
item(log.task || log.stream || "log", [log.message, log.bytes].filter(Boolean).join(" "))
|
|
);
|
|
case "clusterflux.artifacts":
|
|
return state.artifacts.map((artifact) =>
|
|
item(artifact.path || artifact.id || "artifact", [artifact.status, artifact.size].filter(Boolean).join(" "))
|
|
);
|
|
case "clusterflux.inspector":
|
|
return state.inspector.map((entry) =>
|
|
item(entry.label || entry.name || "inspector", entry.value || entry.detail || "")
|
|
);
|
|
default:
|
|
return [];
|
|
}
|
|
}
|
|
|
|
function treeItemsForView(projectRoot, descriptor, liveProcesses = null) {
|
|
const state = projectRoot ? loadClusterfluxViewState(projectRoot) : emptyClusterfluxViewState();
|
|
if (descriptor.id === "clusterflux.processes" && liveProcesses) {
|
|
if (liveProcesses.error) {
|
|
return [
|
|
item("Live process state unavailable", liveProcesses.error, {
|
|
contextValue: "clusterflux.processError"
|
|
})
|
|
];
|
|
}
|
|
state.processes = liveProcesses.processes;
|
|
}
|
|
const items = clusterfluxViewItems(state, descriptor.id);
|
|
return items.length > 0 ? items : [item(descriptor.emptyLabel)];
|
|
}
|
|
|
|
function toVsCodeTreeItem(viewItem) {
|
|
const treeItem = new vscode.TreeItem(
|
|
viewItem.label,
|
|
vscode.TreeItemCollapsibleState.None
|
|
);
|
|
treeItem.description = viewItem.description;
|
|
treeItem.tooltip = viewItem.description || viewItem.label;
|
|
treeItem.contextValue = viewItem.contextValue;
|
|
treeItem.command = viewItem.command;
|
|
return treeItem;
|
|
}
|
|
|
|
function resolveClusterfluxDebugConfiguration(folder, config = {}) {
|
|
const project = resolveProjectPath(folder, config.project);
|
|
return {
|
|
...config,
|
|
name:
|
|
config.name ||
|
|
(config.request === "attach"
|
|
? "Clusterflux: Attach to Virtual Process"
|
|
: "Clusterflux: Launch Virtual Process"),
|
|
type: "clusterflux",
|
|
request: config.request || "launch",
|
|
entry: config.entry || "build",
|
|
project,
|
|
runtimeBackend: config.runtimeBackend || "local-services"
|
|
};
|
|
}
|
|
|
|
function debugAdapterExecutableSpec(
|
|
projectRoot,
|
|
adapterWorkspace = path.resolve(__dirname, "..")
|
|
) {
|
|
const workspaceAdapter = executableWorkspaceBinary(projectRoot, "clusterflux-debug-dap");
|
|
if (workspaceAdapter) {
|
|
return {
|
|
command: workspaceAdapter,
|
|
args: [],
|
|
options: { cwd: projectRoot }
|
|
};
|
|
}
|
|
|
|
if (!hasCargoWorkspace(adapterWorkspace)) {
|
|
return {
|
|
command: "clusterflux-debug-dap",
|
|
args: [],
|
|
options: { cwd: projectRoot || process.cwd() }
|
|
};
|
|
}
|
|
|
|
return {
|
|
command: "cargo",
|
|
args: ["run", "-q", "-p", "clusterflux-dap", "--bin", "clusterflux-debug-dap"],
|
|
options: { cwd: adapterWorkspace }
|
|
};
|
|
}
|
|
|
|
function registerClusterfluxViews(context) {
|
|
if (!vscode) return null;
|
|
const workspaceRoot =
|
|
vscode.workspace.workspaceFolders &&
|
|
vscode.workspace.workspaceFolders[0] &&
|
|
vscode.workspace.workspaceFolders[0].uri.fsPath;
|
|
const emitters = new Map();
|
|
let liveProcesses = null;
|
|
const refreshProcesses = () => {
|
|
liveProcesses = workspaceRoot ? loadLiveProcesses(workspaceRoot) : null;
|
|
const emitter = emitters.get("clusterflux.processes");
|
|
if (emitter) emitter.fire();
|
|
return liveProcesses;
|
|
};
|
|
for (const descriptor of clusterfluxViewDescriptors()) {
|
|
const emitter = new vscode.EventEmitter();
|
|
emitters.set(descriptor.id, emitter);
|
|
context.subscriptions.push(
|
|
vscode.window.registerTreeDataProvider(descriptor.id, {
|
|
onDidChangeTreeData: emitter.event,
|
|
getTreeItem(item) {
|
|
return item;
|
|
},
|
|
getChildren() {
|
|
if (descriptor.id === "clusterflux.processes" && liveProcesses === null) {
|
|
refreshProcesses();
|
|
}
|
|
return treeItemsForView(workspaceRoot, descriptor, liveProcesses).map(toVsCodeTreeItem);
|
|
}
|
|
}),
|
|
emitter
|
|
);
|
|
}
|
|
if (workspaceRoot && vscode.workspace.createFileSystemWatcher) {
|
|
const watcher = vscode.workspace.createFileSystemWatcher(
|
|
new vscode.RelativePattern(workspaceRoot, ".clusterflux/views.json")
|
|
);
|
|
const refresh = () => emitters.forEach((emitter) => emitter.fire());
|
|
context.subscriptions.push(
|
|
watcher,
|
|
watcher.onDidChange(refresh),
|
|
watcher.onDidCreate(refresh),
|
|
watcher.onDidDelete(refresh)
|
|
);
|
|
}
|
|
context.subscriptions.push(
|
|
vscode.commands.registerCommand("clusterflux.refreshProcesses", refreshProcesses)
|
|
);
|
|
return { workspaceRoot, refreshProcesses, getLiveProcesses: () => liveProcesses };
|
|
}
|
|
|
|
function commandProcessId(value) {
|
|
if (typeof value === "string") return value;
|
|
return value && (value.processId || value.label);
|
|
}
|
|
|
|
function liveDebugConfiguration(workspaceRoot, processId, liveProcesses) {
|
|
return {
|
|
type: "clusterflux",
|
|
request: "attach",
|
|
name: `Clusterflux: Attach to ${processId}`,
|
|
project: workspaceRoot,
|
|
entry: "build",
|
|
runtimeBackend: "live-services",
|
|
processId
|
|
};
|
|
}
|
|
|
|
function processAction(projectRoot, action, processId) {
|
|
return runClusterfluxCliJson(projectRoot, ["process", action, "--process", processId, "--yes"]);
|
|
}
|
|
|
|
function registerProcessCommands(context, viewController) {
|
|
if (!viewController || !viewController.workspaceRoot) return;
|
|
const projectRoot = viewController.workspaceRoot;
|
|
const folder = vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders[0];
|
|
|
|
context.subscriptions.push(
|
|
vscode.commands.registerCommand("clusterflux.process.attach", async (value) => {
|
|
const processId = commandProcessId(value);
|
|
if (!processId) return;
|
|
const live = viewController.refreshProcesses();
|
|
if (live.error) {
|
|
vscode.window.showErrorMessage(`Unable to load Clusterflux process state: ${live.error}`);
|
|
return;
|
|
}
|
|
await vscode.debug.startDebugging(
|
|
folder,
|
|
liveDebugConfiguration(projectRoot, processId, live)
|
|
);
|
|
}),
|
|
vscode.commands.registerCommand("clusterflux.process.cancel", async (value) => {
|
|
const processId = commandProcessId(value);
|
|
if (!processId) return;
|
|
const selected = await vscode.window.showWarningMessage(
|
|
`Request cooperative cancellation of ${processId}? The process remains active until its code exits.`,
|
|
{ modal: true },
|
|
"Request Cancellation"
|
|
);
|
|
if (selected !== "Request Cancellation") return;
|
|
try {
|
|
processAction(projectRoot, "cancel", processId);
|
|
viewController.refreshProcesses();
|
|
vscode.window.showInformationMessage(`Cancellation requested for ${processId}.`);
|
|
} catch (error) {
|
|
vscode.window.showErrorMessage(`Clusterflux cancellation failed: ${error.message}`);
|
|
}
|
|
}),
|
|
vscode.commands.registerCommand("clusterflux.process.abort", async (value) => {
|
|
const processId = commandProcessId(value);
|
|
if (!processId) return;
|
|
const selected = await vscode.window.showWarningMessage(
|
|
`Abort ${processId}? This forcibly terminates the virtual process and releases the project slot.`,
|
|
{ modal: true },
|
|
"Abort Process"
|
|
);
|
|
if (selected !== "Abort Process") return;
|
|
try {
|
|
processAction(projectRoot, "abort", processId);
|
|
viewController.refreshProcesses();
|
|
vscode.window.showInformationMessage(`Aborted ${processId}.`);
|
|
} catch (error) {
|
|
vscode.window.showErrorMessage(`Clusterflux abort failed: ${error.message}`);
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
function existingProcessRelationship(activeProcess, intendedProcessId) {
|
|
return activeProcess && activeProcess.process === intendedProcessId
|
|
? "same_launch_target"
|
|
: "different_launch_target";
|
|
}
|
|
|
|
async function resolveExistingProcessBeforeLaunch(folder, config) {
|
|
if (
|
|
!folder ||
|
|
config.request !== "launch" ||
|
|
config.runtimeBackend !== "live-services" ||
|
|
!config.project
|
|
) {
|
|
return config;
|
|
}
|
|
const live = loadLiveProcesses(config.project);
|
|
if (live.error || live.processes.length === 0) return config;
|
|
|
|
const active = live.processes[0];
|
|
const intendedProcessId =
|
|
config.processId || clusterfluxProcessId(config.project, config.entry || "build");
|
|
const relationship = existingProcessRelationship(active, intendedProcessId);
|
|
const runningId = active.process;
|
|
const detail = `${runningId} is ${active.state || "running"} in Coordinator Project ${
|
|
live.project || "selected by the authenticated CLI session"
|
|
}.`;
|
|
|
|
const choices =
|
|
relationship === "same_launch_target"
|
|
? [
|
|
{ label: "Attach", description: "Debug the existing virtual process.", action: "attach" },
|
|
{ label: "Restart", description: "Restart this virtual process with the current launch.", action: "restart" },
|
|
...(active.state === "cancelling"
|
|
? []
|
|
: [{ label: "Request cancellation", description: "Let the process handle cancellation and exit.", action: "cancel" }]),
|
|
{ label: "Abort and launch", description: "Forcibly terminate it, then start this launch.", action: "abort_launch" },
|
|
{ label: "Show details", description: detail, action: "details" },
|
|
{ label: "Cancel launch", description: "Leave the running process unchanged.", action: "dismiss" }
|
|
]
|
|
: [
|
|
{ label: "Show running process", description: detail, action: "details" },
|
|
...(active.state === "cancelling"
|
|
? []
|
|
: [{ label: "Request cancellation", description: "Ask the other process to exit cooperatively.", action: "cancel" }]),
|
|
{ label: "Abort it and launch this workspace", description: "Forcibly free this Coordinator Project slot.", action: "abort_launch" },
|
|
{ label: "Use another Coordinator Project", description: "Keep the other process and select a different authenticated project.", action: "other_project" },
|
|
{ label: "Cancel launch", description: "Leave the running process unchanged.", action: "dismiss" }
|
|
];
|
|
|
|
const selected = await vscode.window.showQuickPick(choices, {
|
|
title:
|
|
relationship === "same_launch_target"
|
|
? "This Clusterflux virtual process is already running"
|
|
: "Another launch is using this Coordinator Project",
|
|
placeHolder: detail,
|
|
ignoreFocusOut: true
|
|
});
|
|
if (!selected || selected.action === "dismiss") return undefined;
|
|
if (selected.action === "details") {
|
|
await vscode.window.showInformationMessage(detail, { modal: true });
|
|
return undefined;
|
|
}
|
|
if (selected.action === "other_project") {
|
|
await vscode.window.showInformationMessage(
|
|
`Choose or create another Coordinator Project with the Clusterflux CLI, then run \`clusterflux project select\` from this workspace. The current project is ${
|
|
live.project || "the project in the authenticated CLI session"
|
|
}.`,
|
|
{ modal: true }
|
|
);
|
|
return undefined;
|
|
}
|
|
if (selected.action === "cancel") {
|
|
processAction(config.project, "cancel", runningId);
|
|
vscode.commands.executeCommand("clusterflux.refreshProcesses");
|
|
return undefined;
|
|
}
|
|
if (selected.action === "abort_launch") {
|
|
processAction(config.project, "abort", runningId);
|
|
vscode.commands.executeCommand("clusterflux.refreshProcesses");
|
|
return config;
|
|
}
|
|
if (selected.action === "attach") {
|
|
return {
|
|
...config,
|
|
request: "attach",
|
|
name: `Clusterflux: Attach to ${runningId}`,
|
|
processId: runningId
|
|
};
|
|
}
|
|
if (selected.action === "restart") {
|
|
return { ...config, processId: runningId, restartExisting: true };
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function activate(context) {
|
|
if (!vscode) return;
|
|
|
|
const diagnostics = vscode.languages.createDiagnosticCollection("clusterflux");
|
|
context.subscriptions.push(diagnostics);
|
|
const viewController = registerClusterfluxViews(context);
|
|
registerProcessCommands(context, viewController);
|
|
|
|
const refresh = (document) => {
|
|
if (document.languageId !== "rust") return;
|
|
const folder = vscode.workspace.getWorkspaceFolder(document.uri);
|
|
if (!folder) return;
|
|
const environmentNames = discoverEnvironmentNames(folder.uri.fsPath);
|
|
const items = diagnoseEnvReferences(document.getText(), environmentNames).map((diagnostic) => {
|
|
const start = document.positionAt(diagnostic.start);
|
|
const end = document.positionAt(diagnostic.end);
|
|
return new vscode.Diagnostic(
|
|
new vscode.Range(start, end),
|
|
diagnostic.message,
|
|
vscode.DiagnosticSeverity.Error
|
|
);
|
|
});
|
|
diagnostics.set(document.uri, items);
|
|
};
|
|
|
|
context.subscriptions.push(
|
|
vscode.workspace.onDidOpenTextDocument(refresh),
|
|
vscode.workspace.onDidChangeTextDocument((event) => refresh(event.document)),
|
|
vscode.workspace.onDidSaveTextDocument(refresh),
|
|
vscode.debug.registerDebugAdapterDescriptorFactory("clusterflux", {
|
|
createDebugAdapterDescriptor(session) {
|
|
const folder = session.workspaceFolder;
|
|
const project = session.configuration.project || (folder && folder.uri.fsPath);
|
|
if (!project) {
|
|
throw new Error("Clusterflux debug launch requires a workspace folder or project path.");
|
|
}
|
|
const adapterWorkspace = path.resolve(__dirname, "..");
|
|
refreshBundleBeforeLaunch(project, adapterWorkspace);
|
|
const spec = debugAdapterExecutableSpec(project, adapterWorkspace);
|
|
return new vscode.DebugAdapterExecutable(
|
|
spec.command,
|
|
spec.args,
|
|
spec.options
|
|
);
|
|
}
|
|
}),
|
|
vscode.debug.registerDebugConfigurationProvider("clusterflux", {
|
|
async resolveDebugConfiguration(folder, config) {
|
|
const resolved = resolveClusterfluxDebugConfiguration(folder, config);
|
|
return resolveExistingProcessBeforeLaunch(folder, resolved);
|
|
}
|
|
})
|
|
);
|
|
|
|
for (const document of vscode.workspace.textDocuments) {
|
|
refresh(document);
|
|
}
|
|
}
|
|
|
|
function deactivate() {}
|
|
|
|
module.exports = {
|
|
activate,
|
|
deactivate,
|
|
bundleInspectCommand,
|
|
debugAdapterExecutableSpec,
|
|
diagnoseEnvReferences,
|
|
clusterfluxCliCommand,
|
|
clusterfluxProcessId,
|
|
clusterfluxViewDescriptors,
|
|
clusterfluxViewItems,
|
|
clusterfluxViewStatePath,
|
|
discoverEnvironmentNames,
|
|
findEnvReferences,
|
|
existingProcessRelationship,
|
|
loadLiveProcesses,
|
|
loadClusterfluxViewState,
|
|
registerClusterfluxViews,
|
|
refreshBundleBeforeLaunch,
|
|
runClusterfluxCliJson,
|
|
resolveClusterfluxDebugConfiguration
|
|
};
|