feat：移除了弹窗，服务器添加sls

packages/api-client/src/modules/archon/actions/v1.ts

@@ -0,0 +1,35 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+export class ArchonActionsV1Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_actions_v1'
+	}
+
+	/**
+	 * Get server action log entries.
+	 * GET /v1/servers/:server_id/action-log
+	 */
+	public async list(
+		serverId: string,
+		options: Archon.Actions.v1.ListActionLogOptions = {},
+	): Promise<Archon.Actions.v1.ActionLogResponse> {
+		const params: Record<string, string | number> = {}
+		if (options.filter) params.filter = JSON.stringify(options.filter)
+		if (options.limit !== undefined) params.limit = options.limit
+		if (options.offset !== undefined) params.offset = options.offset
+		if (options.order !== undefined) params.order = options.order
+		if (options.min_datetime !== undefined) params.min_datetime = options.min_datetime
+		if (options.max_datetime !== undefined) params.max_datetime = options.max_datetime
+
+		return this.client.request<Archon.Actions.v1.ActionLogResponse>(
+			`/servers/${serverId}/action-log`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'GET',
+				params: Object.keys(params).length > 0 ? params : undefined,
+			},
+		)
+	}
+}

packages/api-client/src/modules/archon/backups-queue/v1.ts

@@ -0,0 +1,113 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+export class ArchonBackupsQueueV1Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_backups_queue_v1'
+	}
+
+	/** GET /v1/servers/:server_id/worlds/:world_id/backups-queue */
+	public async list(
+		serverId: string,
+		worldId: string,
+	): Promise<Archon.BackupsQueue.v1.BackupsQueueResponse> {
+		return this.client.request<Archon.BackupsQueue.v1.BackupsQueueResponse>(
+			`/servers/${serverId}/worlds/${worldId}/backups-queue`,
+			{ api: 'archon', version: 1, method: 'GET' },
+		)
+	}
+
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups-queue */
+	public async create(
+		serverId: string,
+		worldId: string,
+		request: Archon.BackupsQueue.v1.BackupRequest,
+	): Promise<Archon.BackupsQueue.v1.PostBackupQueueResponse> {
+		return this.client.request<Archon.BackupsQueue.v1.PostBackupQueueResponse>(
+			`/servers/${serverId}/worlds/${worldId}/backups-queue`,
+			{ api: 'archon', version: 1, method: 'POST', body: request },
+		)
+	}
+
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups-queue/history/create/:operation_id/ack */
+	public async ackCreate(serverId: string, worldId: string, operationId: number): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/backups-queue/history/create/${operationId}/ack`,
+			{ api: 'archon', version: 1, method: 'POST' },
+		)
+	}
+
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups-queue/history/create/:operation_id/cancel */
+	public async cancelCreate(serverId: string, worldId: string, operationId: number): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/backups-queue/history/create/${operationId}/cancel`,
+			{ api: 'archon', version: 1, method: 'POST' },
+		)
+	}
+
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups-queue/history/restore/:operation_id/ack */
+	public async ackRestore(serverId: string, worldId: string, operationId: number): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/backups-queue/history/restore/${operationId}/ack`,
+			{ api: 'archon', version: 1, method: 'POST' },
+		)
+	}
+
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups-queue/history/restore/:operation_id/cancel */
+	public async cancelRestore(
+		serverId: string,
+		worldId: string,
+		operationId: number,
+	): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/backups-queue/history/restore/${operationId}/cancel`,
+			{ api: 'archon', version: 1, method: 'POST' },
+		)
+	}
+
+	/** DELETE /v1/servers/:server_id/worlds/:world_id/backups-queue/:backup_id */
+	public async delete(serverId: string, worldId: string, backupId: string): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/backups-queue/${backupId}`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'DELETE',
+			},
+		)
+	}
+
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups-queue/delete-many */
+	public async deleteMany(serverId: string, worldId: string, backupIds: string[]): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/backups-queue/delete-many`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'POST',
+				body: { backup_ids: backupIds } satisfies Archon.BackupsQueue.v1.DeleteManyBackupRequest,
+			},
+		)
+	}
+
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups-queue/:backup_id/restore */
+	public async restore(
+		serverId: string,
+		worldId: string,
+		backupId: string,
+		request: Archon.BackupsQueue.v1.BackupRequest,
+	): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/backups-queue/${backupId}/restore`,
+			{ api: 'archon', version: 1, method: 'POST', body: request },
+		)
+	}
+
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups-queue/:backup_id/retry */
+	public async retry(serverId: string, worldId: string, backupId: string): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/backups-queue/${backupId}/retry`,
+			{ api: 'archon', version: 1, method: 'POST' },
+		)
+	}
+}

packages/api-client/src/modules/archon/backups/v1.ts

@@ -0,0 +1,113 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+/**
+ * @deprecated Use `client.archon.backups_queue_v1` (Backups Queue API) instead.
+ */
+export class ArchonBackupsV1Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_backups_v1'
+	}
+
+	/**
+	 * @deprecated Use `client.archon.backups_queue_v1.list` instead.
+	 */
+	/** GET /v1/servers/:server_id/worlds/:world_id/backups */
+	public async list(serverId: string, worldId: string): Promise<Archon.Backups.v1.Backup[]> {
+		return this.client.request<Archon.Backups.v1.Backup[]>(
+			`/servers/${serverId}/worlds/${worldId}/backups`,
+			{ api: 'archon', version: 1, method: 'GET' },
+		)
+	}
+
+	/**
+	 * @deprecated Use `client.archon.backups_queue_v1.list` instead.
+	 */
+	/** GET /v1/servers/:server_id/worlds/:world_id/backups/:backup_id */
+	public async get(
+		serverId: string,
+		worldId: string,
+		backupId: string,
+	): Promise<Archon.Backups.v1.Backup> {
+		return this.client.request<Archon.Backups.v1.Backup>(
+			`/servers/${serverId}/worlds/${worldId}/backups/${backupId}`,
+			{ api: 'archon', version: 1, method: 'GET' },
+		)
+	}
+
+	/**
+	 * @deprecated Use `client.archon.backups_queue_v1.create` instead.
+	 */
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups */
+	public async create(
+		serverId: string,
+		worldId: string,
+		request: Archon.Backups.v1.BackupRequest,
+	): Promise<Archon.Backups.v1.PostBackupResponse> {
+		return this.client.request<Archon.Backups.v1.PostBackupResponse>(
+			`/servers/${serverId}/worlds/${worldId}/backups`,
+			{ api: 'archon', version: 1, method: 'POST', body: request },
+		)
+	}
+
+	/**
+	 * @deprecated Use `client.archon.backups_queue_v1.restore` instead.
+	 */
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups/:backup_id/restore */
+	public async restore(serverId: string, worldId: string, backupId: string): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/backups/${backupId}/restore`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'POST',
+			},
+		)
+	}
+
+	/**
+	 * @deprecated Use `client.archon.backups_queue_v1.delete` for backup deletion, or
+	 * `client.archon.backups_queue_v1.cancelCreate` / `cancelRestore` for active operations.
+	 */
+	/** DELETE /v1/servers/:server_id/worlds/:world_id/backups/:backup_id */
+	public async delete(serverId: string, worldId: string, backupId: string): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/backups/${backupId}`, {
+			api: 'archon',
+			version: 1,
+			method: 'DELETE',
+		})
+	}
+
+	/**
+	 * @deprecated Use `client.archon.backups_queue_v1.retry` instead.
+	 */
+	/** POST /v1/servers/:server_id/worlds/:world_id/backups/:backup_id/retry */
+	public async retry(serverId: string, worldId: string, backupId: string): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/backups/${backupId}/retry`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'POST',
+			},
+		)
+	}
+
+	/**
+	 * @deprecated Legacy backups only; no queue equivalent. Prefer renaming via other supported flows if available.
+	 */
+	/** PATCH /v1/servers/:server_id/worlds/:world_id/backups/:backup_id */
+	public async rename(
+		serverId: string,
+		worldId: string,
+		backupId: string,
+		request: Archon.Backups.v1.PatchBackup,
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/backups/${backupId}`, {
+			api: 'archon',
+			version: 1,
+			method: 'PATCH',
+			body: request,
+		})
+	}
+}

packages/api-client/src/modules/archon/content/v1.ts

@@ -0,0 +1,290 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+export class ArchonContentV1Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_content_v1'
+	}
+
+	/** GET /v1/:server_id/worlds/:world_id/addons */
+	public async getAddons(
+		serverId: string,
+		worldId: string,
+		options?: {
+			from_modpack?: boolean
+			disabled?: boolean
+			addons?: boolean
+			updates?: boolean
+		},
+	): Promise<Archon.Content.v1.Addons> {
+		const params = new URLSearchParams()
+		if (options?.from_modpack !== undefined)
+			params.set('from_modpack', String(options.from_modpack))
+		if (options?.disabled !== undefined) params.set('disabled', String(options.disabled))
+		if (options?.addons !== undefined) params.set('addons', String(options.addons))
+		if (options?.updates !== undefined) params.set('updates', String(options.updates))
+		const query = params.toString()
+
+		return this.client.request<Archon.Content.v1.Addons>(
+			`/servers/${serverId}/worlds/${worldId}/addons${query ? `?${query}` : ''}`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'GET',
+			},
+		)
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/addons */
+	public async addAddon(
+		serverId: string,
+		worldId: string,
+		request: Archon.Content.v1.AddAddonRequest,
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/addons`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: request,
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/addons/install-many */
+	public async addAddons(
+		serverId: string,
+		worldId: string,
+		addons: Archon.Content.v1.AddAddonRequest[],
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/addons/install-many`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: addons satisfies Archon.Content.v1.AddAddonsRequest,
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/addons/delete */
+	public async deleteAddon(
+		serverId: string,
+		worldId: string,
+		request: Archon.Content.v1.RemoveAddonRequest,
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/addons/delete`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: request,
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/addons/disable */
+	public async disableAddon(
+		serverId: string,
+		worldId: string,
+		request: Archon.Content.v1.RemoveAddonRequest,
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/addons/disable`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: request,
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/addons/enable */
+	public async enableAddon(
+		serverId: string,
+		worldId: string,
+		request: Archon.Content.v1.RemoveAddonRequest,
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/addons/enable`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: request,
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/addons/delete-many */
+	public async deleteAddons(
+		serverId: string,
+		worldId: string,
+		items: Archon.Content.v1.RemoveAddonRequest[],
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/addons/delete-many`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: { items },
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/addons/disable-many */
+	public async disableAddons(
+		serverId: string,
+		worldId: string,
+		items: Archon.Content.v1.RemoveAddonRequest[],
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/addons/disable-many`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: { items },
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/addons/enable-many */
+	public async enableAddons(
+		serverId: string,
+		worldId: string,
+		items: Archon.Content.v1.RemoveAddonRequest[],
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/addons/enable-many`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: { items },
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/content */
+	public async installContent(
+		serverId: string,
+		worldId: string,
+		request: Archon.Content.v1.InstallWorldContent,
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/content`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: request,
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/content/repair */
+	public async repair(serverId: string, worldId: string): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/content/repair`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/content/unlink-modpack */
+	public async unlinkModpack(serverId: string, worldId: string): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/content/unlink-modpack`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'POST',
+			},
+		)
+	}
+
+	/** GET /v1/:server_id/worlds/:world_id/addons/update?filename=... */
+	public async getAddonUpdate(
+		serverId: string,
+		worldId: string,
+		filename: string,
+	): Promise<Archon.Content.v1.Addon> {
+		return this.client.request<Archon.Content.v1.Addon>(
+			`/servers/${serverId}/worlds/${worldId}/addons/update?filename=${encodeURIComponent(filename)}`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'GET',
+			},
+		)
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/addons/update */
+	public async updateAddon(
+		serverId: string,
+		worldId: string,
+		request: Archon.Content.v1.UpdateAddonRequest,
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/addons/update`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: request,
+		})
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/addons/update-many */
+	public async updateAddons(
+		serverId: string,
+		worldId: string,
+		addons: Archon.Content.v1.UpdateAddonRequest[],
+	): Promise<void> {
+		await this.client.request<void>(`/servers/${serverId}/worlds/${worldId}/addons/update-many`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: { addons },
+		})
+	}
+
+	/** GET /v1/:server_id/worlds/:world_id/content/modpack/update */
+	public async getModpackUpdate(
+		serverId: string,
+		worldId: string,
+	): Promise<Archon.Content.v1.ModpackFields> {
+		return this.client.request<Archon.Content.v1.ModpackFields>(
+			`/servers/${serverId}/worlds/${worldId}/content/modpack/update`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'GET',
+			},
+		)
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/content/modpack/update */
+	public async updateModpack(serverId: string, worldId: string): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/content/modpack/update`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'POST',
+			},
+		)
+	}
+
+	/** GET /v1/:server_id/worlds/:world_id/content/update-game-version?game_version=... */
+	public async getUpdateGameVersionPreview(
+		serverId: string,
+		worldId: string,
+		gameVersion: string,
+		signal?: AbortSignal,
+	): Promise<Archon.Content.v1.UpdateGameVersionPreview> {
+		return this.client.request<Archon.Content.v1.UpdateGameVersionPreview>(
+			`/servers/${serverId}/worlds/${worldId}/content/update-game-version?game_version=${encodeURIComponent(gameVersion)}`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'GET',
+				timeout: 1000 * 1000,
+				signal,
+			},
+		)
+	}
+
+	/** POST /v1/:server_id/worlds/:world_id/content/update-game-version?game_version=... */
+	public async applyGameVersionUpdate(
+		serverId: string,
+		worldId: string,
+		gameVersion: string,
+	): Promise<void> {
+		await this.client.request<void>(
+			`/servers/${serverId}/worlds/${worldId}/content/update-game-version?game_version=${encodeURIComponent(gameVersion)}`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'POST',
+			},
+		)
+	}
+}

packages/api-client/src/modules/archon/index.ts

@@ -0,0 +1,8 @@
+export * from './actions/v1'
+export * from './backups/v1'
+export * from './backups-queue/v1'
+export * from './content/v1'
+export * from './properties/v1'
+export * from './servers/v0'
+export * from './servers/v1'
+export * from './types'

packages/api-client/src/modules/archon/nodes/internal.ts

@@ -0,0 +1,20 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+export class ArchonNodesInternalModule extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_nodes_internal'
+	}
+
+	/**
+	 * Get node hostnames and region summary for admin tooling.
+	 * GET /_internal/nodes/overview
+	 */
+	public async overview(): Promise<Archon.Nodes.Internal.Overview> {
+		return this.client.request<Archon.Nodes.Internal.Overview>('/nodes/overview', {
+			api: 'archon',
+			version: 'internal',
+			method: 'GET',
+		})
+	}
+}

packages/api-client/src/modules/archon/notices/v0.ts

@@ -0,0 +1,98 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+export class ArchonNoticesV0Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_notices_v0'
+	}
+
+	/**
+	 * Get all server notices.
+	 * GET /modrinth/v0/notices
+	 */
+	public async list(): Promise<Archon.Notices.v0.ListedNotice[]> {
+		return this.client.request<Archon.Notices.v0.ListedNotice[]>('/notices', {
+			api: 'archon',
+			version: 'modrinth/v0',
+			method: 'GET',
+		})
+	}
+
+	/**
+	 * Create a server notice.
+	 * POST /modrinth/v0/notices
+	 */
+	public async create(
+		request: Archon.Notices.v0.Announce,
+	): Promise<Archon.Notices.v0.PostNoticeResponseBody> {
+		return this.client.request<Archon.Notices.v0.PostNoticeResponseBody>('/notices', {
+			api: 'archon',
+			version: 'modrinth/v0',
+			method: 'POST',
+			body: request,
+		})
+	}
+
+	/**
+	 * Update a server notice.
+	 * PATCH /modrinth/v0/notices/:id
+	 */
+	public async update(id: number, request: Archon.Notices.v0.AnnouncePatch): Promise<void> {
+		await this.client.request(`/notices/${id}`, {
+			api: 'archon',
+			version: 'modrinth/v0',
+			method: 'PATCH',
+			body: request,
+		})
+	}
+
+	/**
+	 * Delete a server notice.
+	 * DELETE /modrinth/v0/notices/:id
+	 */
+	public async delete(id: number): Promise<void> {
+		await this.client.request(`/notices/${id}`, {
+			api: 'archon',
+			version: 'modrinth/v0',
+			method: 'DELETE',
+		})
+	}
+
+	/**
+	 * Assign a notice to a server or node.
+	 * PUT /modrinth/v0/notices/:id/assign?server=:serverId
+	 * PUT /modrinth/v0/notices/:id/assign?node=:nodeId
+	 */
+	public async assign(id: number, target: Archon.Notices.v0.AssignmentTarget): Promise<void> {
+		await this.client.request(`/notices/${id}/assign`, {
+			api: 'archon',
+			version: 'modrinth/v0',
+			method: 'PUT',
+			params: this.assignmentTargetToParams(target),
+		})
+	}
+
+	/**
+	 * Unassign a notice from a server or node.
+	 * PUT /modrinth/v0/notices/:id/unassign?server=:serverId
+	 * PUT /modrinth/v0/notices/:id/unassign?node=:nodeId
+	 */
+	public async unassign(id: number, target: Archon.Notices.v0.AssignmentTarget): Promise<void> {
+		await this.client.request(`/notices/${id}/unassign`, {
+			api: 'archon',
+			version: 'modrinth/v0',
+			method: 'PUT',
+			params: this.assignmentTargetToParams(target),
+		})
+	}
+
+	private assignmentTargetToParams(
+		target: Archon.Notices.v0.AssignmentTarget,
+	): Record<string, string> {
+		if ('server' in target) {
+			return { server: target.server }
+		}
+
+		return { node: target.node }
+	}
+}

packages/api-client/src/modules/archon/options/v1.ts

@@ -0,0 +1,37 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+export class ArchonOptionsV1Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_options_v1'
+	}
+
+	/** GET /v1/servers/:server_id/worlds/:world_id/options/startup */
+	public async getStartup(
+		serverId: string,
+		worldId: string,
+	): Promise<Archon.Content.v1.RuntimeOptions> {
+		return this.client.request<Archon.Content.v1.RuntimeOptions>(
+			`/servers/${serverId}/worlds/${worldId}/options/startup`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'GET',
+			},
+		)
+	}
+
+	/** PATCH /v1/servers/:server_id/worlds/:world_id/options/startup */
+	public async patchStartup(
+		serverId: string,
+		worldId: string,
+		body: Archon.Content.v1.PatchRuntimeOptions,
+	): Promise<void> {
+		await this.client.request(`/servers/${serverId}/worlds/${worldId}/options/startup`, {
+			api: 'archon',
+			version: 1,
+			method: 'PATCH',
+			body,
+		})
+	}
+}

packages/api-client/src/modules/archon/properties/v1.ts

@@ -0,0 +1,40 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+export class ArchonPropertiesV1Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_properties_v1'
+	}
+
+	/** GET /v1/servers/:server_id/worlds/:world_id/properties */
+	public async getProperties(
+		serverId: string,
+		worldId: string,
+	): Promise<Archon.Content.v1.PropertiesFields> {
+		return this.client.request<Archon.Content.v1.PropertiesFields>(
+			`/servers/${serverId}/worlds/${worldId}/properties`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'GET',
+			},
+		)
+	}
+
+	/** PATCH /v1/servers/:server_id/worlds/:world_id/properties */
+	public async patchProperties(
+		serverId: string,
+		worldId: string,
+		body: Archon.Content.v1.PatchPropertiesFields,
+	): Promise<Archon.Content.v1.PropertiesFields> {
+		return this.client.request<Archon.Content.v1.PropertiesFields>(
+			`/servers/${serverId}/worlds/${worldId}/properties`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'PATCH',
+				body,
+			},
+		)
+	}
+}

packages/api-client/src/modules/archon/server-users/v1.ts

@@ -0,0 +1,83 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+export class ArchonServerUsersV1Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_server_users_v1'
+	}
+
+	/**
+	 * Get list of users with access to a server
+	 * GET /v1/servers/:server_id/users
+	 */
+	public async list(serverId: string): Promise<Archon.ServerUsers.v1.ServerUser[]> {
+		return this.client.request<Archon.ServerUsers.v1.ServerUser[]>(`/servers/${serverId}/users`, {
+			api: 'archon',
+			version: 1,
+			method: 'GET',
+		})
+	}
+
+	/**
+	 * Add a user to a server
+	 * POST /v1/servers/:server_id/users
+	 */
+	public async add(
+		serverId: string,
+		user: Archon.ServerUsers.v1.AddServerUserRequest,
+	): Promise<void> {
+		await this.client.request(`/servers/${serverId}/users`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+			body: user,
+		})
+	}
+
+	/**
+	 * Re-send an invite to a pending server user.
+	 * POST /v1/servers/:server_id/users/:user_id/reinvite
+	 */
+	public async reinvite(
+		serverId: string,
+		userId: string,
+	): Promise<Archon.ServerUsers.v1.ReinviteResponse> {
+		return this.client.request<Archon.ServerUsers.v1.ReinviteResponse>(
+			`/servers/${serverId}/users/${userId}/reinvite`,
+			{
+				api: 'archon',
+				version: 1,
+				method: 'POST',
+			},
+		)
+	}
+
+	/**
+	 * Remove a user from a server
+	 * DELETE /v1/servers/:server_id/users/:user_id
+	 */
+	public async delete(serverId: string, userId: string): Promise<void> {
+		await this.client.request(`/servers/${serverId}/users/${userId}`, {
+			api: 'archon',
+			version: 1,
+			method: 'DELETE',
+		})
+	}
+
+	/**
+	 * Update a user's server role
+	 * PATCH /v1/servers/:server_id/users/:user_id
+	 */
+	public async update(
+		serverId: string,
+		userId: string,
+		role: Archon.ServerUsers.v1.AssignableServerUserRole,
+	): Promise<void> {
+		await this.client.request(`/servers/${serverId}/users/${userId}`, {
+			api: 'archon',
+			version: 1,
+			method: 'PATCH',
+			body: JSON.stringify(role),
+		})
+	}
+}

packages/api-client/src/modules/archon/servers/v0.ts

@@ -0,0 +1,321 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { UploadHandle, UploadProgress } from '../../../types/upload'
+import type { Archon } from '../types'
+
+export class ArchonServersV0Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_servers_v0'
+	}
+
+	/**
+	 * Get a specific server by ID
+	 * GET /modrinth/v0/servers/:id
+	 */
+	public async get(serverId: string): Promise<Archon.Servers.v0.Server> {
+		return this.client.request<Archon.Servers.v0.Server>(`/servers/${serverId}`, {
+			api: 'archon',
+			method: 'GET',
+			version: 'modrinth/v0',
+		})
+	}
+
+	/**
+	 * Get list of servers for the authenticated user
+	 * GET /modrinth/v0/servers
+	 */
+	public async list(
+		options?: Archon.Servers.v0.GetServersOptions,
+	): Promise<Archon.Servers.v0.ServerGetResponse> {
+		const params = new URLSearchParams()
+		if (options?.limit) params.set('limit', options.limit.toString())
+		if (options?.offset) params.set('offset', options.offset.toString())
+
+		const query = params.toString() ? `?${params.toString()}` : ''
+
+		return this.client.request<Archon.Servers.v0.ServerGetResponse>(`servers${query}`, {
+			api: 'archon',
+			method: 'GET',
+			version: 'modrinth/v0',
+		})
+	}
+
+	/**
+	 * Check stock availability for a region
+	 * POST /modrinth/v0/stock?region=:region
+	 */
+	public async checkStock(
+		region: string,
+		request: Archon.Servers.v0.StockRequest,
+	): Promise<Archon.Servers.v0.StockResponse> {
+		return this.client.request<Archon.Servers.v0.StockResponse>(`/stock?region=${region}`, {
+			api: 'archon',
+			version: 'modrinth/v0',
+			method: 'POST',
+			body: request,
+			skipAuth: true,
+		})
+	}
+
+	/**
+	 * Check stock availability (without region filter)
+	 * POST /modrinth/v0/stock
+	 */
+	public async checkStockGlobal(
+		request: Archon.Servers.v0.StockRequest,
+	): Promise<Archon.Servers.v0.StockResponse> {
+		return this.client.request<Archon.Servers.v0.StockResponse>('/stock', {
+			api: 'archon',
+			version: 'modrinth/v0',
+			method: 'POST',
+			body: request,
+			skipAuth: true,
+		})
+	}
+
+	/**
+	 * Get filesystem authentication credentials for a server
+	 * Returns URL and JWT token for accessing the server's filesystem via Kyros
+	 * GET /modrinth/v0/servers/:id/fs
+	 */
+	public async getFilesystemAuth(serverId: string): Promise<Archon.Servers.v0.JWTAuth> {
+		return this.client.request<Archon.Servers.v0.JWTAuth>(`/servers/${serverId}/fs`, {
+			api: 'archon',
+			version: 'modrinth/v0',
+			method: 'GET',
+		})
+	}
+
+	/**
+	 * Get WebSocket authentication credentials for a server
+	 * GET /modrinth/v0/servers/:id/ws
+	 */
+	public async getWebSocketAuth(serverId: string): Promise<Archon.Websocket.v0.WSAuth> {
+		return this.client.request<Archon.Websocket.v0.WSAuth>(`/servers/${serverId}/ws`, {
+			api: 'archon',
+			version: 'modrinth/v0',
+			method: 'GET',
+		})
+	}
+
+	/**
+	 * Send a power action to a server (Start, Stop, Restart, Kill)
+	 * POST /modrinth/v0/servers/:id/power
+	 */
+	public async power(
+		serverId: string,
+		action: 'Start' | 'Stop' | 'Restart' | 'Kill',
+	): Promise<void> {
+		await this.client.request(`/servers/${serverId}/power`, {
+			api: 'archon',
+			method: 'POST',
+			version: 'modrinth/v0',
+			body: { action },
+		})
+	}
+
+	/**
+	 * Reinstall a server with a new loader or modpack
+	 * POST /modrinth/v0/servers/:id/reinstall
+	 */
+	public async reinstall(
+		serverId: string,
+		request: Archon.Servers.v0.ReinstallRequest,
+		hardReset: boolean = false,
+	): Promise<void> {
+		await this.client.request(`/servers/${serverId}/reinstall`, {
+			api: 'archon',
+			method: 'POST',
+			version: 'modrinth/v0',
+			params: { hard: String(hardReset) },
+			body: request,
+		})
+	}
+
+	/**
+	 * Get authentication credentials for .mrpack file upload
+	 * GET /modrinth/v0/servers/:id/reinstallFromMrpack
+	 */
+	public async getReinstallMrpackAuth(
+		serverId: string,
+	): Promise<Archon.Servers.v0.MrpackReinstallAuth> {
+		return this.client.request<Archon.Servers.v0.MrpackReinstallAuth>(
+			`/servers/${serverId}/reinstallFromMrpack`,
+			{
+				api: 'archon',
+				version: 'modrinth/v0',
+				method: 'GET',
+			},
+		)
+	}
+
+	/**
+	 * Reinstall a server from a .mrpack file with progress tracking
+	 *
+	 * Two-step flow: fetches upload auth, then uploads the .mrpack file to the node.
+	 *
+	 * @param serverId - Server ID
+	 * @param file - .mrpack file to upload
+	 * @param hardReset - Whether to erase all server data
+	 * @param options - Optional progress callback
+	 * @returns Promise resolving to an UploadHandle with progress tracking and cancellation
+	 */
+	public async reinstallFromMrpack(
+		serverId: string,
+		file: File,
+		hardReset: boolean = false,
+		options?: {
+			onProgress?: (progress: UploadProgress) => void
+		},
+	): Promise<UploadHandle<void>> {
+		const auth = await this.getReinstallMrpackAuth(serverId)
+
+		const formData = new FormData()
+		formData.append('file', file)
+
+		return this.client.upload<void>('', {
+			api: `https://${auth.url}`,
+			version: 'reinstallMrpackMultiparted',
+			formData,
+			params: { hard: String(hardReset) },
+			headers: { Authorization: `Bearer ${auth.token}` },
+			skipAuth: true,
+			onProgress: options?.onProgress,
+			retry: false,
+		})
+	}
+
+	/**
+	 * Update a server's name
+	 * POST /modrinth/v0/servers/:id/name
+	 */
+	public async updateName(serverId: string, name: string): Promise<void> {
+		await this.client.request(`/servers/${serverId}/name`, {
+			api: 'archon',
+			method: 'POST',
+			version: 'modrinth/v0',
+			body: { name },
+		})
+	}
+
+	/**
+	 * Get allocations for a server
+	 * GET /modrinth/v0/servers/:id/allocations
+	 */
+	public async getAllocations(serverId: string): Promise<Archon.Servers.v0.Allocation[]> {
+		return this.client.request<Archon.Servers.v0.Allocation[]>(`/servers/${serverId}/allocations`, {
+			api: 'archon',
+			method: 'GET',
+			version: 'modrinth/v0',
+		})
+	}
+
+	/**
+	 * Reserve a new allocation for a server
+	 * POST /modrinth/v0/servers/:id/allocations?name=...
+	 */
+	public async reserveAllocation(
+		serverId: string,
+		name: string,
+	): Promise<Archon.Servers.v0.Allocation> {
+		return this.client.request<Archon.Servers.v0.Allocation>(`/servers/${serverId}/allocations`, {
+			api: 'archon',
+			method: 'POST',
+			version: 'modrinth/v0',
+			params: { name },
+		})
+	}
+
+	/**
+	 * Update an allocation's name
+	 * PUT /modrinth/v0/servers/:id/allocations/:port?name=...
+	 */
+	public async updateAllocation(serverId: string, port: number, name: string): Promise<void> {
+		await this.client.request(`/servers/${serverId}/allocations/${port}`, {
+			api: 'archon',
+			method: 'PUT',
+			version: 'modrinth/v0',
+			params: { name },
+		})
+	}
+
+	/**
+	 * Delete an allocation
+	 * DELETE /modrinth/v0/servers/:id/allocations/:port
+	 */
+	public async deleteAllocation(serverId: string, port: number): Promise<void> {
+		await this.client.request(`/servers/${serverId}/allocations/${port}`, {
+			api: 'archon',
+			method: 'DELETE',
+			version: 'modrinth/v0',
+		})
+	}
+
+	/**
+	 * Check if a subdomain is available
+	 * GET /modrinth/v0/subdomains/:subdomain/isavailable
+	 */
+	public async checkSubdomainAvailability(subdomain: string): Promise<{ available: boolean }> {
+		return this.client.request<{ available: boolean }>(`/subdomains/${subdomain}/isavailable`, {
+			api: 'archon',
+			method: 'GET',
+			version: 'modrinth/v0',
+		})
+	}
+
+	/**
+	 * Change a server's subdomain
+	 * POST /modrinth/v0/servers/:id/subdomain
+	 */
+	public async changeSubdomain(serverId: string, subdomain: string): Promise<void> {
+		await this.client.request(`/servers/${serverId}/subdomain`, {
+			api: 'archon',
+			method: 'POST',
+			version: 'modrinth/v0',
+			body: { subdomain },
+		})
+	}
+
+	/**
+	 * Get startup configuration for a server
+	 * GET /modrinth/v0/servers/:id/startup
+	 */
+	public async getStartupConfig(serverId: string): Promise<Archon.Servers.v0.StartupConfig> {
+		return this.client.request<Archon.Servers.v0.StartupConfig>(`/servers/${serverId}/startup`, {
+			api: 'archon',
+			method: 'GET',
+			version: 'modrinth/v0',
+		})
+	}
+
+	/**
+	 * Update startup configuration for a server
+	 * POST /modrinth/v0/servers/:id/startup
+	 */
+	public async updateStartupConfig(
+		serverId: string,
+		config: {
+			invocation: string | null
+			jdk_version: string | null
+			jdk_build: string | null
+		},
+	): Promise<void> {
+		await this.client.request(`/servers/${serverId}/startup`, {
+			api: 'archon',
+			method: 'POST',
+			version: 'modrinth/v0',
+			body: config,
+		})
+	}
+
+	/**
+	 * Dismiss a server notice
+	 * POST /modrinth/v0/servers/:id/notices/:noticeId/dismiss
+	 */
+	public async dismissNotice(serverId: string, noticeId: number): Promise<void> {
+		await this.client.request(`/servers/${serverId}/notices/${noticeId}/dismiss`, {
+			api: 'archon',
+			method: 'POST',
+			version: 'modrinth/v0',
+		})
+	}
+}

packages/api-client/src/modules/archon/servers/v1.ts

@@ -0,0 +1,69 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+export class ArchonServersV1Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_servers_v1'
+	}
+
+	/**
+	 * Get list of servers for the authenticated user
+	 * GET /v1/servers
+	 */
+	public async list(): Promise<Archon.Servers.v1.ServerFull[]> {
+		return this.client.request<Archon.Servers.v1.ServerFull[]>('/servers', {
+			api: 'archon',
+			version: 1,
+			method: 'GET',
+		})
+	}
+
+	/**
+	 * Get full server details including worlds, backups, and content
+	 * GET /v1/servers/:server_id
+	 */
+	public async get(serverId: string): Promise<Archon.Servers.v1.ServerFull> {
+		return this.client.request<Archon.Servers.v1.ServerFull>(`/servers/${serverId}`, {
+			api: 'archon',
+			version: 1,
+			method: 'GET',
+		})
+	}
+
+	/**
+	 * Get available regions
+	 * GET /v1/regions
+	 */
+	public async getRegions(): Promise<Archon.Servers.v1.Region[]> {
+		return this.client.request<Archon.Servers.v1.Region[]>('/regions', {
+			api: 'archon',
+			version: 1,
+			method: 'GET',
+			skipAuth: true,
+		})
+	}
+
+	/**
+	 * End the intro flow for a server
+	 * DELETE /v1/servers/:id/flows/intro
+	 */
+	public async endIntro(serverId: string): Promise<void> {
+		await this.client.request(`/servers/${serverId}/flows/intro`, {
+			api: 'archon',
+			version: 1,
+			method: 'DELETE',
+		})
+	}
+
+	/**
+	 * Reset a world to onboarding
+	 * POST /v1/servers/:id/worlds/:wid/onboard
+	 */
+	public async resetToOnboarding(serverId: string, worldId: string): Promise<void> {
+		await this.client.request(`/servers/${serverId}/worlds/${worldId}/onboard`, {
+			api: 'archon',
+			version: 1,
+			method: 'POST',
+		})
+	}
+}

packages/api-client/src/modules/archon/transfers/internal.ts

@@ -0,0 +1,84 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Archon } from '../types'
+
+export class ArchonTransfersInternalModule extends AbstractModule {
+	public getModuleID(): string {
+		return 'archon_transfers_internal'
+	}
+
+	/**
+	 * Schedule transfers for specific servers.
+	 * POST /_internal/transfers/schedule/servers
+	 */
+	public async scheduleServers(
+		request: Archon.Transfers.Internal.ScheduleServerTransfersRequest,
+	): Promise<Archon.Transfers.Internal.ScheduleTransfersResponse> {
+		return this.client.request<Archon.Transfers.Internal.ScheduleTransfersResponse>(
+			'/transfers/schedule/servers',
+			{
+				api: 'archon',
+				version: 'internal',
+				method: 'POST',
+				body: request,
+			},
+		)
+	}
+
+	/**
+	 * Schedule transfers for all servers on specific nodes.
+	 * POST /_internal/transfers/schedule/nodes
+	 */
+	public async scheduleNodes(
+		request: Archon.Transfers.Internal.ScheduleNodeTransfersRequest,
+	): Promise<Archon.Transfers.Internal.ScheduleTransfersResponse> {
+		return this.client.request<Archon.Transfers.Internal.ScheduleTransfersResponse>(
+			'/transfers/schedule/nodes',
+			{
+				api: 'archon',
+				version: 'internal',
+				method: 'POST',
+				body: request,
+			},
+		)
+	}
+
+	/**
+	 * Get transfer batch history.
+	 * GET /_internal/transfers/history
+	 */
+	public async history(
+		options?: Archon.Transfers.Internal.TransferHistoryQuery,
+	): Promise<Archon.Transfers.Internal.TransferHistoryResponse> {
+		const params: Record<string, number> = {}
+		if (options?.page !== undefined) params.page = options.page
+		if (options?.page_size !== undefined) params.page_size = options.page_size
+
+		return this.client.request<Archon.Transfers.Internal.TransferHistoryResponse>(
+			'/transfers/history',
+			{
+				api: 'archon',
+				version: 'internal',
+				method: 'GET',
+				params,
+			},
+		)
+	}
+
+	/**
+	 * Cancel pending transfer batches.
+	 * POST /_internal/transfers/cancel
+	 */
+	public async cancel(
+		request: Archon.Transfers.Internal.CancelTransfersRequest,
+	): Promise<Archon.Transfers.Internal.CancelTransfersResponse> {
+		return this.client.request<Archon.Transfers.Internal.CancelTransfersResponse>(
+			'/transfers/cancel',
+			{
+				api: 'archon',
+				version: 'internal',
+				method: 'POST',
+				body: request,
+			},
+		)
+	}
+}