Files
factorio-clusterio/packages/web_ui/src/components/InstanceViewPage.tsx
T
bbassieandClaude Opus 5.5 a6b44e78d6 Tidy up web interface buttons and labels
Rename save Copy to Duplicate, shorten the save buttons, move Load
scenario into the instance control button and Create template into
More, square off the online players table, show the bind address and
public URL on the controller page, restyle the user settings like the
role page, add a favicon with a controller.favicon_url override, and
put the page name in the tab title.

Closes #1260

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 22:03:02 +00:00

378 lines
13 KiB
TypeScript

import React, { useContext, useState } from "react";
import { useNavigate, useParams } from "react-router-dom";
import {
Button, Descriptions, Dropdown, Flex, MenuProps, Modal, Segmented, Space, Tag, Tooltip, Typography,
message,
} from "antd";
import CopyOutlined from "@ant-design/icons/CopyOutlined";
import DeleteOutlined from "@ant-design/icons/DeleteOutlined";
import DownOutlined from "@ant-design/icons/DownOutlined";
import * as lib from "@clusterio/lib";
import { useAccount } from "../model/account";
import ControlContext from "./ControlContext";
import PageHeader from "./PageHeader";
import PageLayout from "./PageLayout";
import PluginExtra from "./PluginExtra";
import ResourceNotes from "./ResourceNotes";
import ResourceState from "./ResourceState";
import InstanceConfigTree from "./InstanceConfigTree";
import LogConsole, { SelectMaxLogLevel } from "./LogConsole";
import InstanceRcon from "./InstanceRcon";
import AssignInstanceModal from "./AssignInstanceModal";
import InstanceControlButton, { InstanceControlButtonPermissions } from "./InstanceControlButton";
import LoadScenarioModal from "./LoadScenarioModal";
import SavesList from "./SavesList";
import OnlinePlayersList from "./OnlinePlayersList";
import { notifyErrorHandler } from "../util/notify";
import { useInstance, useInstances } from "../model/instance";
import { CreateInstanceButton, CreateInstanceModal } from "./InstancesPage";
import { useHost } from "../model/host";
import InstanceStatusTag from "./InstanceStatusTag";
import Link from "./Link";
import { instanceModPack, instancePublicAddress } from "../util/instance";
import { useDefaultModPack, useModPacks } from "../model/mod_pack";
import InstanceModPack from "./InstanceModPack";
import useLocalStorage from "../util/useLocalStorage";
import useResourceState from "../util/useResourceState";
import usePluginActions from "../util/usePluginActions";
import { MetricRelativeDate } from "./system_metrics";
type MenuItem = Required<MenuProps>["items"][number];
const { Title } = Typography;
// Remembers the console "Game/Instance" selection across reloads (defaults to game).
const consoleActionsOnlyKey = "instance-console-actions-only";
type InstanceDescriptionProps = {
host?: Readonly<lib.HostDetails>;
instance: Readonly<lib.InstanceDetails>;
};
function TemplateDescription(props: { instance: Readonly<lib.InstanceDetails> }) {
const [instances] = useInstances();
const inheritors = [...instances.values()].filter(i => i.templateId === props.instance.id);
return <Descriptions bordered size="small" column={1}>
<Descriptions.Item label="Inherited by">
{inheritors.length
? <Space wrap>
{inheritors.map(i => <Link key={i.id} to={`/instances/${i.id}/view`}>{i.name}</Link>)}
</Space>
: <em>No instances</em>}
</Descriptions.Item>
{props.instance.templateId !== undefined && <Descriptions.Item label="Template">
<TemplateLink id={props.instance.templateId} />
</Descriptions.Item>}
<Descriptions.Item label="Mod Pack">
<ModPackDescription modPackId={props.instance.modPackId} />
</Descriptions.Item>
</Descriptions>;
}
function ModPackDescription(props: { modPackId?: number }) {
const [modPacks] = useModPacks();
const defaultModPack = useDefaultModPack();
return <InstanceModPack resolved={instanceModPack(props.modPackId, modPacks, defaultModPack)} />;
}
function TemplateLink(props: { id: number }) {
const [template] = useInstance(props.id);
return <Link to={`/instances/${props.id}/view`}>{template?.name ?? props.id}</Link>;
}
function InstanceDescription(props: InstanceDescriptionProps) {
let account = useAccount();
const { host, instance } = props;
let assigned = instance.assignedHost !== undefined;
const publicAddress = instancePublicAddress(instance, host);
return <Descriptions
bordered
size="small"
column={{ xs: 1, md: 2, lg: 2, xl: 2, xxl: 2 }}
>
<Descriptions.Item label="Host">
{!assigned
? <em>Unassigned</em>
: <Link to={`/hosts/${host?.id ?? instance.assignedHost}/view`}>
{host?.name ?? instance.assignedHost}
</Link>
}
{account.hasPermission("core.instance.assign") && <AssignInstanceModal
id={instance.id}
hostId={instance.assignedHost}
buttonProps={{
size: "small",
style: { float: "right" },
type: assigned ? "default" : "primary",
disabled: !["unknown", "unassigned", "stopped"].includes(instance.status!),
}}
buttonContent={assigned ? "Reassign" : "Assign"}
/>}
</Descriptions.Item>
<Descriptions.Item label="Public address">
{publicAddress
? <Space>
{publicAddress}
<Button
type="text"
size="small"
icon={<CopyOutlined />}
onClick={() => {
navigator.clipboard.writeText(publicAddress);
message.success("Copied public address!");
}}
/>
</Space>
: <em>N/A</em>}
</Descriptions.Item>
<Descriptions.Item label="Version">
{instance.factorioVersion ?? "unknown"}
</Descriptions.Item>
<Descriptions.Item label="Mod Pack">
<ModPackDescription modPackId={instance.modPackId} />
</Descriptions.Item>
<Descriptions.Item label="Last Start Time">
<MetricRelativeDate timeMs={instance.startedAtMs}/>
</Descriptions.Item>
{instance.templateId !== undefined && <Descriptions.Item label="Template">
<TemplateLink id={instance.templateId} />
</Descriptions.Item>}
</Descriptions>;
}
function InstanceButtons(props: { instance: lib.InstanceDetails }) {
let account = useAccount();
let control = useContext(ControlContext);
let navigate = useNavigate();
let [exportingData, setExportingData] = useState(false);
const [modal, setModal] = useState<"scenario" | "template">();
let instance = props.instance;
let instanceId = instance.id!;
let [host] = useHost(instance.assignedHost);
const [instances] = useInstances();
const canCreate = account.hasPermission("core.instance.create");
const pluginActions = usePluginActions("InstanceViewPage", { instance });
let instanceButtonMenuItems: MenuItem[] = [];
if (canCreate) {
instanceButtonMenuItems.push({ key: "template", label: "Create template" });
}
if (account.hasPermission("core.instance.export_data")) {
instanceButtonMenuItems.push({
disabled: exportingData || instance.status !== "stopped",
key: "export",
label: "Export data",
});
}
if (account.hasPermission("core.instance.extract_players")) {
instanceButtonMenuItems.push({
disabled: instance.status !== "running",
key: "extract",
label: "Extract players from save",
});
}
instanceButtonMenuItems.push(...pluginActions);
if (account.hasPermission("core.instance.delete")) {
if (instanceButtonMenuItems.length) {
instanceButtonMenuItems.push({ type: "divider" });
}
instanceButtonMenuItems.push({
disabled: !["unknown", "unassigned", "stopped"].includes(instance.status),
danger: true,
key: "delete",
icon: <DeleteOutlined />,
label: "Delete",
});
}
function confirmDelete() {
Modal.confirm({
autoFocusButton: "cancel",
content: "Permanently delete instance and server saves?",
okText: "Delete",
okButtonProps: { danger: true },
onOk: () => {
control.send(
new lib.InstanceDeleteRequest(instanceId)
).then(() => {
navigate("/instances");
}).catch(notifyErrorHandler("Error deleting instance"));
},
});
}
let instanceButtonsMenuProps: MenuProps = {
items: instanceButtonMenuItems,
onClick: ({ key }: { key: string }) => {
if (key === "template") {
setModal("template");
} else if (key === "export") {
setExportingData(true);
control.sendTo(
{ instanceId },
new lib.InstanceExportDataRequest(),
).catch(
notifyErrorHandler("Error exporting data")
).finally(() => {
setExportingData(false);
});
} else if (key === "extract") {
control.sendTo(
{ instanceId },
new lib.InstanceExtractPlayersRequest(),
).catch(notifyErrorHandler("Error extracting player data"));
} else if (key === "delete") {
confirmDelete();
}
},
};
if (instance.isTemplate) {
return <Space wrap>
{canCreate && <CreateInstanceButton
instances={instances}
initial={{ template: instanceId }}
buttonText="Create instance from template"
/>}
{account.hasPermission("core.instance.delete") && <Button
danger
icon={<DeleteOutlined />}
onClick={confirmDelete}
>Delete</Button>}
{pluginActions.length > 0
&& <Dropdown placement="bottomRight" trigger={["click"]} menu={{ items: pluginActions }}>
<Button>More <DownOutlined /></Button>
</Dropdown>}
</Space>;
}
const canLoadScenario = account.hasPermission("core.instance.load_scenario");
return <Space wrap>
{
account.hasAnyPermission(...InstanceControlButtonPermissions, "core.instance.load_scenario")
&& <InstanceControlButton
instance={instance}
extraActions={canLoadScenario ? [{
key: "scenario",
label: "Load scenario",
disabled: instance.status !== "stopped",
onClick: () => setModal("scenario"),
}] : []}
/>
}
<Button
onClick={() => {
const address = instancePublicAddress(instance, host);
if (address) {
window.location.href = `steam://run/427520//--mp-connect=${address}`;
}
}}
disabled={instance.status !== "running" || !instancePublicAddress(instance, host)}
>
Connect via Steam
</Button>
{instanceButtonMenuItems.length > 0
&& <Dropdown placement="bottomRight" trigger={["click"]} menu={instanceButtonsMenuProps}>
<Button>More <DownOutlined /></Button>
</Dropdown>}
{canLoadScenario && <LoadScenarioModal
instance={instance}
open={modal === "scenario"}
onClose={() => setModal(undefined)}
/>}
{canCreate && <CreateInstanceModal
instances={instances}
initial={{ instanceClone: instanceId, asTemplate: true, linkSource: true }}
open={modal === "template"}
onClose={() => setModal(undefined)}
/>}
</Space>;
}
export default function InstanceViewPage() {
let params = useParams();
let instanceId = Number(params.id);
const [maxLevel, setMaxLevel] = useState<keyof typeof lib.levels>("server");
const [actionsOnly, setActionsOnly] = useLocalStorage(consoleActionsOnlyKey, true);
let navigate = useNavigate();
let account = useAccount();
let [instance, synced, error] = useInstance(instanceId);
const state = useResourceState(instance, synced, error, instanceId);
let [host] = useHost(instance?.assignedHost);
let nav = [{ name: "Instances", path: "/instances" }, { name: instance?.name ?? String(instanceId) }];
if (!instance) {
return <ResourceState
state={state} type="Instance" id={instanceId} nav={nav} listPath="/instances" error={error}
/>;
}
return <PageLayout nav={nav}>
<PageHeader
title={instance.name ?? ""}
status={instance.isTemplate
? <Tag color="purple">Template</Tag>
: <InstanceStatusTag status={instance.status} />}
extra={<InstanceButtons instance={instance} />}
/>
{instance.isTemplate
? <TemplateDescription instance={instance} />
: <InstanceDescription host={host} instance={instance} />}
<ResourceNotes resourceType="instance" resourceId={instanceId} />
{!instance.isTemplate && <>
{account.hasPermission("core.user.list") && <OnlinePlayersList instanceId={instanceId} />}
{
account.hasAllPermission("core.instance.save.list", "core.instance.save.subscribe")
&& <SavesList instance={instance} />
}
{
account.hasAnyPermission("core.log.follow", "core.instance.send_rcon")
&& <Flex justify="space-between" align="baseline">
<Title level={5} style={{ marginTop: 16 }}>Console</Title>
{
account.hasPermission("core.log.follow")
&& <Flex align="center" gap="middle">
<Tooltip
title={
"Game filters to in-game actions and errors: player chat, joins, leaves, etc." +
"Instance is the full unfiltered log including the engine log."
}
>
<Segmented
value={actionsOnly ? "game" : "instance"}
onChange={value => setActionsOnly(value === "game")}
options={[
{ label: "Game", value: "game" },
{ label: "Instance", value: "instance" },
]}
/>
</Tooltip>
<SelectMaxLogLevel
value={maxLevel}
onChange={setMaxLevel}
hidden={["http"]}
/>
</Flex>
}
</Flex>
}
{
account.hasPermission("core.log.follow")
&& <LogConsole instances={[instanceId]} maxLevel={maxLevel} actionsOnly={actionsOnly}/>
}
{
account.hasPermission("core.instance.send_rcon")
&& <InstanceRcon id={instanceId} disabled={instance.status !== "running"} />
}
</>}
{account.hasPermission("core.instance.get_config") && <InstanceConfigTree id={instanceId} />}
<PluginExtra component="InstanceViewPage" instance={instance} />
</PageLayout>;
}