3260 lines
175 KiB
JavaScript
3260 lines
175 KiB
JavaScript
import assert from 'node:assert/strict'
|
||
import { EventEmitter } from 'node:events'
|
||
import { request as httpRequest } from 'node:http'
|
||
import { createConnection } from 'node:net'
|
||
import { appendFile, lstat, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from 'node:fs/promises'
|
||
import { tmpdir } from 'node:os'
|
||
import { join } from 'node:path'
|
||
import { PassThrough } from 'node:stream'
|
||
import test from 'node:test'
|
||
import { JsonlLogManager } from '../../control-plane/modules/log-manager/index.mjs'
|
||
import { parseCli, readSecret, recoverImageBaseline, resetTrust, runCli } from '../../control-plane/services/management/cli.mjs'
|
||
import { API_PREFIX, createManagementServer, listenManagement } from '../../control-plane/services/management/server.mjs'
|
||
import { LocalApiClient } from '../../control-plane/modules/updater/lib/client.mjs'
|
||
import { UpdateConflictError } from '../../control-plane/modules/updater/lib/coordinator.mjs'
|
||
import { UpdateScheduler } from '../../control-plane/modules/updater/lib/scheduler.mjs'
|
||
import { SettingsDocumentStore } from '../../control-plane/services/management/settings-document.mjs'
|
||
import { UserPluginInventory } from '../../control-plane/modules/plugin-manager/user-inventory.mjs'
|
||
import { UserPluginJournal } from '../../control-plane/modules/plugin-manager/user-journal.mjs'
|
||
import { UserPluginSnapshots } from '../../control-plane/modules/plugin-manager/user-snapshots.mjs'
|
||
import { UserPluginSelectionStore } from '../../control-plane/modules/plugin-manager/user-state.mjs'
|
||
import { UserPluginTransactionManager } from '../../control-plane/modules/plugin-manager/user-transaction.mjs'
|
||
import { FileInventory, FileSearchManager } from '../../control-plane/modules/file-manager/index.mjs'
|
||
import { FileTransferManager } from '../../control-plane/modules/file-manager/transfers.mjs'
|
||
import { FileTaskManager } from '../../control-plane/modules/file-manager/tasks.mjs'
|
||
import { AtomicFileEditor } from '../../control-plane/modules/file-manager/editor.mjs'
|
||
|
||
const ASYNC_POLL_ATTEMPTS = 2_000
|
||
const ASYNC_POLL_INTERVAL_MS = 5
|
||
|
||
class Coordinator extends EventEmitter {
|
||
constructor() {
|
||
super()
|
||
this.value = { status: 'idle', progress: 0 }
|
||
this.state = { read: async () => this.value }
|
||
}
|
||
|
||
async publicStatus() {
|
||
return { update: this.value, updateChannel: 'experimental', holds: [], experimentalBlocked: null, rollbackPlan: { planId: 'plan-a' } }
|
||
}
|
||
|
||
hasActiveTask() { return this.running === true }
|
||
|
||
async check(source) {
|
||
this.checkSource = source
|
||
return { value: { targetSequence: 2, desired: { dsh: { version: 'rc.8' } } } }
|
||
}
|
||
|
||
start() {
|
||
if (this.running) throw new UpdateConflictError('busy')
|
||
this.running = true
|
||
return { taskId: 'task-one', completion: new Promise(() => {}) }
|
||
}
|
||
|
||
startReconcile() { return this.start() }
|
||
rollbackPlan() { return Promise.resolve({ planId: 'plan-a' }) }
|
||
setChannel(channel) { return Promise.resolve({ updateChannel: channel, holds: [], experimentalBlocked: null }) }
|
||
retryHold(id) { return Promise.resolve({ retried: id }) }
|
||
startCompleteRollback(planId) {
|
||
assert.equal(planId, 'plan-a')
|
||
return { taskId: 'rollback-task', completion: Promise.resolve() }
|
||
}
|
||
}
|
||
|
||
function rawRequest(socketPath, path, method = 'GET') {
|
||
return new Promise((resolve, reject) => {
|
||
const request = httpRequest({ socketPath, path, method }, response => {
|
||
const chunks = []
|
||
response.on('data', chunk => chunks.push(chunk))
|
||
response.on('end', () => resolve({
|
||
status: response.statusCode,
|
||
headers: response.headers,
|
||
body: Buffer.concat(chunks).toString('utf8'),
|
||
}))
|
||
})
|
||
request.once('error', reject)
|
||
request.end()
|
||
})
|
||
}
|
||
|
||
function rawUpgrade(socketPath, path) {
|
||
return new Promise((resolve, reject) => {
|
||
const socket = createConnection(socketPath)
|
||
const chunks = []
|
||
socket.once('connect', () => socket.write([
|
||
`GET ${path} HTTP/1.1`,
|
||
'Host: management.internal',
|
||
'Connection: Upgrade',
|
||
'Upgrade: websocket',
|
||
'Sec-WebSocket-Key: dGVzdC1rZXk=',
|
||
'Sec-WebSocket-Version: 13',
|
||
'', '',
|
||
].join('\r\n')))
|
||
socket.on('data', chunk => chunks.push(chunk))
|
||
socket.once('error', reject)
|
||
socket.once('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
|
||
})
|
||
}
|
||
|
||
test('management preserves capability backend failures for HTTP and WebSocket requests', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-capability-'))
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const authorizeInternal = async () => {
|
||
throw Object.assign(new Error('Access Manager unavailable'), { statusCode: 503 })
|
||
}
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(), logs, authorizeInternal,
|
||
terminalSessions: { upgrade() { assert.fail('unauthorized terminal upgrade reached execution point') } },
|
||
})
|
||
const socketPath = join(root, 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
try {
|
||
const response = await rawRequest(socketPath, `${API_PREFIX}status`)
|
||
assert.equal(response.status, 503)
|
||
assert.equal(JSON.parse(response.body).error, 'Access Manager unavailable')
|
||
assert.match(await rawUpgrade(socketPath, `${API_PREFIX}terminal/sessions/00000000-0000-4000-8000-000000000000/stream`), /^HTTP\/1\.1 503 Service Unavailable/m)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
await rm(root, { recursive: true, force: true })
|
||
}
|
||
})
|
||
|
||
test('management socket exposes status, check, update, logs, and local rollback', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-'))
|
||
const coordinator = new Coordinator()
|
||
const originTransitions = []
|
||
const totpEnrollments = []
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
await logs.append('gateway', 'stdout', 'ready')
|
||
const server = createManagementServer({
|
||
coordinator,
|
||
logs,
|
||
platformStatus: async () => ({ environment: 'one' }),
|
||
updateAutomaticCheck: async value => value,
|
||
getAuthenticationSettings: async () => ({ account: { username: 'admin' } }),
|
||
updateAuthenticationSettings: async value => ({ account: { username: value.username } }),
|
||
beginTotpEnrollment: async value => {
|
||
totpEnrollments.push({ action: 'begin', value })
|
||
return { enrollmentToken: 'dshte_test', qrCode: 'data:image/svg+xml,test', secret: 'SECRET' }
|
||
},
|
||
confirmTotpEnrollment: async value => {
|
||
totpEnrollments.push({ action: 'confirm', value })
|
||
return { confirmed: true }
|
||
},
|
||
cancelTotpEnrollment: async value => {
|
||
totpEnrollments.push({ action: 'cancel', value })
|
||
return { canceled: true }
|
||
},
|
||
beginTotpDisableConfirmation: async value => {
|
||
totpEnrollments.push({ action: 'disable-begin', value })
|
||
return { confirmationToken: 'dshtd_test' }
|
||
},
|
||
confirmTotpDisable: async value => {
|
||
totpEnrollments.push({ action: 'disable-confirm', value })
|
||
return { confirmed: true }
|
||
},
|
||
cancelTotpDisableConfirmation: async value => {
|
||
totpEnrollments.push({ action: 'disable-cancel', value })
|
||
return { canceled: true }
|
||
},
|
||
revokeAuthenticationSessions: async value => ({ revoked: value.scope === 'all' ? 2 : 1 }),
|
||
createManagementOriginTransition: async value => {
|
||
originTransitions.push({ stage: 'create', value })
|
||
return { transition: { transitionId: 'transition-one', nonce: 'nonce-one' } }
|
||
},
|
||
commitManagementOriginTransition: async value => {
|
||
originTransitions.push({ stage: 'commit', value })
|
||
return { account: { managementAccess: { mode: 'isolated' } } }
|
||
},
|
||
reportManagementOriginTransitionFailure: async value => {
|
||
originTransitions.push({ stage: 'failure', value })
|
||
return { reported: true }
|
||
},
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
const status = await client.request('GET', '/_dsh_platform/api/v1/status')
|
||
assert.equal(status.environment, 'one')
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/check', { source: 'page-open' })).targetSequence, 2)
|
||
assert.equal(coordinator.checkSource, 'page-open')
|
||
assert.deepEqual(await client.request('POST', '/_dsh_platform/api/v1/update'), { taskId: 'task-one' })
|
||
await assert.rejects(client.request('POST', '/_dsh_platform/api/v1/update'), error => error.statusCode === 409)
|
||
const rejected = await logs.query({ sources: ['platform-management'] })
|
||
assert.equal(rejected.some(entry => entry.message === 'management.request.failed'
|
||
&& entry.pathname === '/_dsh_platform/api/v1/update'
|
||
&& entry.level === 'warning'), true)
|
||
assert.equal((await client.request('GET', '/_dsh_platform/api/v1/logs?source=gateway')).entries[0].message, 'ready')
|
||
assert.equal((await client.request('PUT', '/_dsh_platform/api/v1/channel', { channel: 'experimental' })).updateChannel, 'experimental')
|
||
assert.deepEqual(await client.request('PUT', '/_dsh_platform/api/v1/automatic-check', {
|
||
enabled: true, intervalSeconds: 21_600, notificationsEnabled: false,
|
||
}), { enabled: true, intervalSeconds: 21_600, notificationsEnabled: false })
|
||
assert.equal((await client.request('GET', '/_dsh_platform/api/v1/auth-settings')).account.username, 'admin')
|
||
assert.equal((await client.request('PUT', '/_dsh_platform/api/v1/auth-settings', { username: 'operator' })).account.username, 'operator')
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/auth-totp/enrollments', {
|
||
currentPassword: 'correct password',
|
||
})).enrollmentToken, 'dshte_test')
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/auth-totp/enrollments/confirm', {
|
||
enrollmentToken: 'dshte_test', totpCode: '123456',
|
||
})).confirmed, true)
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/auth-totp/enrollments/cancel', {
|
||
enrollmentToken: 'dshte_test',
|
||
})).canceled, true)
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/auth-totp/disable-confirmations')).confirmationToken, 'dshtd_test')
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/auth-totp/disable-confirmations/confirm', {
|
||
confirmationToken: 'dshtd_test', totpCode: '123456',
|
||
})).confirmed, true)
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/auth-totp/disable-confirmations/cancel', {
|
||
confirmationToken: 'dshtd_test',
|
||
})).canceled, true)
|
||
assert.deepEqual(totpEnrollments, [
|
||
{ action: 'begin', value: { currentPassword: 'correct password' } },
|
||
{ action: 'confirm', value: { enrollmentToken: 'dshte_test', totpCode: '123456' } },
|
||
{ action: 'cancel', value: { enrollmentToken: 'dshte_test' } },
|
||
{ action: 'disable-begin', value: {} },
|
||
{ action: 'disable-confirm', value: { confirmationToken: 'dshtd_test', totpCode: '123456' } },
|
||
{ action: 'disable-cancel', value: { confirmationToken: 'dshtd_test' } },
|
||
])
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/auth-sessions/revoke', {
|
||
sessionId: 'session-two',
|
||
})).revoked, 1)
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/management-origin/transitions', {
|
||
mode: 'isolated', isolatedEntry: { kind: 'public', managementPublicOrigin: 'https://manage.example' },
|
||
})).transition.transitionId, 'transition-one')
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/management-origin/transitions/commit', {
|
||
transitionId: 'transition-one', proof: 'proof-one',
|
||
})).account.managementAccess.mode, 'isolated')
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/management-origin/transitions/failure', {
|
||
stage: 'browser-probe', mode: 'isolated',
|
||
})).reported, true)
|
||
assert.deepEqual(originTransitions.map(value => value.stage), ['create', 'commit', 'failure'])
|
||
assert.equal((await client.request('POST', '/_dsh_platform/api/v1/holds/retry', { id: 'hold-a' })).retried, 'hold-a')
|
||
assert.equal((await client.request('GET', '/_dsh_platform/api/v1/rollback-plan')).plan.planId, 'plan-a')
|
||
coordinator.running = false
|
||
assert.deepEqual(await client.request('POST', '/_dsh_platform/api/v1/rollback', { planId: 'plan-a' }), { taskId: 'rollback-task' })
|
||
const audit = await logs.query({ sources: ['audit'] })
|
||
assert.equal(audit.some(entry => entry.message === 'update.channel.changed' && entry.updateChannel === 'experimental'), true)
|
||
assert.equal(audit.some(entry => entry.message === 'update.automatic-check.configured' && entry.intervalSeconds === 21_600), true)
|
||
assert.equal(audit.some(entry => entry.message === 'update.hold.retried' && entry.holdId === 'hold-a'), true)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management proxies sanitized outbound configuration, Provider inventory, and structured conflicts', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-outbound-proxy-'))
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const view = {
|
||
schema: 1, enabled: false, revision: 'revision-one', componentReady: true,
|
||
proxy: { protocol: 'http', host: '', port: null, username: '', passwordConfigured: false, remoteDns: true },
|
||
scopes: {}, environment: { allProxy: null },
|
||
modelApi: { default: { proxyEnabled: false }, providers: {} },
|
||
noProxy: { system: ['localhost'], user: [] }, bypass: { additional: [] },
|
||
routeHealth: {}, lastTest: null, scopeCatalog: { schema: 1, entries: [] },
|
||
}
|
||
const providers = { schema: 1, source: 'live', providers: [{ id: 'deepseek', routingCapability: 'shared-dsh' }] }
|
||
const updates = []
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(), logs,
|
||
getProxyConfiguration: async () => view,
|
||
listProxyProviders: async () => providers,
|
||
updateProxyConfiguration: async value => {
|
||
updates.push(value)
|
||
if (value.baseRevision !== view.revision) {
|
||
const error = new Error('proxy configuration changed')
|
||
error.statusCode = 409
|
||
error.code = 'REVISION_CONFLICT'
|
||
error.stage = 'activate'
|
||
error.retryable = true
|
||
error.proxyError = {
|
||
code: error.code, message: error.message, stage: error.stage, retryable: error.retryable,
|
||
}
|
||
throw error
|
||
}
|
||
return { ...view, revision: 'revision-two' }
|
||
},
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
assert.deepEqual(await client.request('GET', `${API_PREFIX}proxy`), view)
|
||
assert.deepEqual(await client.request('GET', `${API_PREFIX}proxy/provider-inventory`), providers)
|
||
const configured = await client.request('PUT', `${API_PREFIX}proxy`, {
|
||
baseRevision: view.revision,
|
||
value: { password: 'must-not-log' },
|
||
})
|
||
assert.equal(configured.revision, 'revision-two')
|
||
assert.deepEqual(updates, [{ baseRevision: view.revision, value: { password: 'must-not-log' } }])
|
||
|
||
const bytes = Buffer.from(JSON.stringify({ baseRevision: 'stale', value: {} }))
|
||
const conflict = await new Promise((resolve, reject) => {
|
||
const outgoing = httpRequest({
|
||
socketPath, method: 'PUT', path: `${API_PREFIX}proxy`,
|
||
headers: { 'content-type': 'application/json', 'content-length': bytes.byteLength },
|
||
}, response => {
|
||
const chunks = []
|
||
response.on('data', chunk => chunks.push(chunk))
|
||
response.on('end', () => resolve({ status: response.statusCode, body: JSON.parse(Buffer.concat(chunks).toString()) }))
|
||
})
|
||
outgoing.once('error', reject)
|
||
outgoing.end(bytes)
|
||
})
|
||
assert.equal(conflict.status, 409)
|
||
assert.deepEqual(conflict.body, { error: {
|
||
code: 'REVISION_CONFLICT', message: 'proxy configuration changed', stage: 'activate', retryable: true,
|
||
} })
|
||
const audit = await logs.query({ sources: ['audit'] })
|
||
assert.equal(audit.some(entry => entry.message === 'proxy.configuration.update.completed' && entry.revision === 'revision-two'), true)
|
||
assert.equal(audit.some(entry => entry.message === 'proxy.configuration.update.failed' && entry.code === 'REVISION_CONFLICT'), true)
|
||
assert.equal(JSON.stringify(audit).includes('must-not-log'), false)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management exposes one reconnectable and cancellable outbound proxy test task', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-proxy-test-'))
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const taskId = '123e4567-e89b-42d3-a456-426614174000'
|
||
let status = 'running'
|
||
let cancelled = false
|
||
const state = () => ({
|
||
schema: 1, taskId, status, baseRevision: 'revision-one', candidateHash: `sha256:${'a'.repeat(64)}`,
|
||
mode: 'proxy', currentStage: status === 'running' ? 'proxy-connect' : null,
|
||
stages: [{ stage: 'proxy-connect', status: status === 'running' ? 'running' : 'success', durationMs: 5, errorCode: null, detail: null }],
|
||
error: null, createdAt: '2026-08-25T00:00:00.000Z', updatedAt: new Date().toISOString(),
|
||
})
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(), logs,
|
||
startProxyTest: async () => state(),
|
||
getProxyTest: async requested => {
|
||
assert.equal(requested, taskId)
|
||
return state()
|
||
},
|
||
cancelProxyTest: async requested => {
|
||
assert.equal(requested, taskId)
|
||
cancelled = true
|
||
status = 'cancelled'
|
||
return state()
|
||
},
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
assert.deepEqual(await client.request('POST', `${API_PREFIX}proxy/test`, {
|
||
baseRevision: 'revision-one', value: {},
|
||
}), { taskId })
|
||
assert.equal((await client.request('GET', `${API_PREFIX}status`)).proxyTestOperation.taskId, taskId)
|
||
assert.equal((await client.request('GET', `${API_PREFIX}proxy/test/tasks/${taskId}`)).status, 'running')
|
||
assert.equal((await client.request('DELETE', `${API_PREFIX}proxy/test/tasks/${taskId}`)).status, 'cancelled')
|
||
assert.equal(cancelled, true)
|
||
let audit
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
audit = await logs.query({ sources: ['audit'] })
|
||
if (audit.some(entry => entry.message === 'proxy.test.cancelled' && entry.taskId === taskId)) break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(audit.some(entry => entry.message === 'proxy.test.started' && entry.taskId === taskId), true)
|
||
assert.equal(audit.some(entry => entry.message === 'proxy.test.stage.changed'
|
||
&& entry.taskId === taskId && entry.stage === 'proxy-connect' && entry.status === 'running'), true)
|
||
assert.equal(audit.some(entry => entry.message === 'proxy.test.stage.changed'
|
||
&& entry.taskId === taskId && entry.stage === 'proxy-connect' && entry.status === 'success'), true)
|
||
assert.equal(audit.some(entry => entry.message === 'proxy.test.cancel-requested' && entry.taskId === taskId), true)
|
||
assert.equal(audit.some(entry => entry.message === 'proxy.test.cancelled' && entry.taskId === taskId), true)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management exposes audited System Skill tasks through the shared runtime mutex', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-system-skills-'))
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
let complete
|
||
const pending = new Promise(resolve => { complete = resolve })
|
||
const calls = []
|
||
const skills = [{
|
||
id: 'dsh-docker-operations', sha256: 'a'.repeat(64),
|
||
description: { zh: '容器操作手册', en: 'Container operations guide' }, installed: true, enabled: true,
|
||
}]
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs,
|
||
listSystemSkills: async () => skills,
|
||
configureSystemSkill: async (skillId, action) => { calls.push({ skillId, action }); await pending },
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
assert.deepEqual((await client.request('GET', `${API_PREFIX}system-skills`)).skills, skills)
|
||
const task = await client.request('POST', `${API_PREFIX}system-skills/action`, {
|
||
skillId: 'dsh-docker-operations', action: 'disable',
|
||
})
|
||
assert.match(task.taskId, /^[0-9a-f-]{36}$/)
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}restart-dsh`), error => error.statusCode === 409)
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}system-skills/action`, {
|
||
skillId: 'dsh-docker-operations', action: 'disable', unexpected: true,
|
||
}), error => error.statusCode === 400)
|
||
complete()
|
||
let status
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.systemSkillOperation.status === 'success') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.systemSkillOperation.status, 'success')
|
||
assert.deepEqual(calls, [{ skillId: 'dsh-docker-operations', action: 'disable' }])
|
||
const audit = await logs.query({ sources: ['audit'] })
|
||
assert.equal(audit.some(entry => entry.message === 'system-skill.disable.started'), true)
|
||
assert.equal(audit.some(entry => entry.message === 'system-skill.disable.completed'), true)
|
||
} finally {
|
||
complete()
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management exposes validated User Skill tasks only on the standalone API', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-user-skills-'))
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
let complete
|
||
const pending = new Promise(resolve => { complete = resolve })
|
||
const revision = `sha256:${'a'.repeat(64)}`
|
||
const entryId = `sha256:${'b'.repeat(64)}`
|
||
const inventory = {
|
||
schema: 1, revision,
|
||
skills: [{ entryId, entryName: 'local-guide', source: 'user-dsh', kind: 'directory', name: 'local-guide', description: 'Local guide', enabled: true, damaged: false, metadataError: null, symbolicLink: false }],
|
||
}
|
||
const calls = []
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs,
|
||
listUserSkills: async () => inventory,
|
||
validateUserSkillAction: async value => {
|
||
if (value.revision !== revision) {
|
||
const error = new Error('User Skill state changed')
|
||
error.statusCode = 409
|
||
throw error
|
||
}
|
||
},
|
||
configureUserSkill: async value => {
|
||
calls.push(value)
|
||
if (value.action === 'delete') throw new Error('permission denied')
|
||
await pending
|
||
},
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
assert.deepEqual(await client.request('GET', `${API_PREFIX}user-skills`), inventory)
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}user-skills/action`, {
|
||
entryId, revision: `sha256:${'c'.repeat(64)}`, action: 'disable',
|
||
}), error => error.statusCode === 409)
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}user-skills/action`, {
|
||
entryId, revision, action: 'disable', unexpected: true,
|
||
}), error => error.statusCode === 400)
|
||
const task = await client.request('POST', `${API_PREFIX}user-skills/action`, { entryId, revision, action: 'disable' })
|
||
assert.match(task.taskId, /^[0-9a-f-]{36}$/)
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}restart-dsh`), error => error.statusCode === 409)
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}user-skills/action`, {
|
||
entryId, revision, action: 'disable',
|
||
}), error => error.statusCode === 409)
|
||
complete()
|
||
let status
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.userSkillOperation.status === 'success') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.userSkillOperation.status, 'success')
|
||
const failedTask = await client.request('POST', `${API_PREFIX}user-skills/action`, { entryId, revision, action: 'delete' })
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.userSkillOperation.taskId === failedTask.taskId && status.userSkillOperation.status === 'failed') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.userSkillOperation.status, 'failed')
|
||
assert.equal(status.userSkillOperation.error, 'permission denied')
|
||
assert.deepEqual(calls, [{ entryId, revision, action: 'disable' }, { entryId, revision, action: 'delete' }])
|
||
const audit = await logs.query({ sources: ['audit'] })
|
||
assert.equal(audit.some(entry => entry.message === 'user-skill.disable.started'), true)
|
||
assert.equal(audit.some(entry => entry.message === 'user-skill.disable.completed'), true)
|
||
assert.equal(audit.some(entry => entry.message === 'user-skill.delete.started'), true)
|
||
assert.equal(audit.some(entry => entry.message === 'user-skill.delete.failed' && entry.error === 'permission denied'), true)
|
||
} finally {
|
||
complete()
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management live logs preserve the requested source filter', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-log-stream-'))
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
await logs.append('gateway', 'stdout', 'initial')
|
||
const server = createManagementServer({ coordinator: new Coordinator(), logs })
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
let request
|
||
let response
|
||
try {
|
||
({ request, response } = await new Promise((resolve, reject) => {
|
||
const nextRequest = httpRequest({ socketPath, path: `${API_PREFIX}logs/stream?source=gateway&limit=10` }, nextResponse => {
|
||
resolve({ request: nextRequest, response: nextResponse })
|
||
})
|
||
nextRequest.once('error', reject)
|
||
nextRequest.end()
|
||
}))
|
||
let body = ''
|
||
const live = new Promise(resolve => {
|
||
response.on('data', chunk => {
|
||
body += chunk.toString('utf8')
|
||
if (body.includes('must-stream')) resolve()
|
||
})
|
||
})
|
||
await logs.append('updater', 'stdout', 'must-not-stream')
|
||
await new Promise(resolve => setTimeout(resolve, 300))
|
||
await appendFile(logs.currentPath('gateway'), `${JSON.stringify({
|
||
timestamp: new Date().toISOString(), source: 'gateway', stream: 'stdout', level: 'info', message: 'must-stream',
|
||
})}\n`)
|
||
await Promise.race([
|
||
live,
|
||
new Promise((_, reject) => setTimeout(() => reject(new Error('timed out waiting for live log')), 1_000)),
|
||
])
|
||
assert.match(body, /must-stream/)
|
||
assert.doesNotMatch(body, /must-not-stream/)
|
||
assert.equal(response.headers['x-accel-buffering'], 'no')
|
||
assert.equal(response.headers['cache-control'], 'no-cache, no-transform')
|
||
} finally {
|
||
request?.destroy()
|
||
response?.destroy()
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management state events keep idle proxy connections alive', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-state-stream-'))
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs: new JsonlLogManager({ root: join(root, 'logs') }),
|
||
stateHeartbeatMs: 10,
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
let request
|
||
let response
|
||
try {
|
||
({ request, response } = await new Promise((resolve, reject) => {
|
||
const nextRequest = httpRequest({ socketPath, path: `${API_PREFIX}events` }, nextResponse => {
|
||
resolve({ request: nextRequest, response: nextResponse })
|
||
})
|
||
nextRequest.once('error', reject)
|
||
nextRequest.end()
|
||
}))
|
||
let body = ''
|
||
await Promise.race([
|
||
new Promise(resolve => {
|
||
response.on('data', chunk => {
|
||
body += chunk.toString('utf8')
|
||
if (body.includes('event: heartbeat')) resolve()
|
||
})
|
||
}),
|
||
new Promise((_, reject) => setTimeout(() => reject(new Error('timed out waiting for state heartbeat')), 1_000)),
|
||
])
|
||
assert.match(body, /event: state/)
|
||
assert.match(body, /event: heartbeat/)
|
||
assert.equal(response.headers['x-accel-buffering'], 'no')
|
||
assert.equal(response.headers['cache-control'], 'no-cache, no-transform')
|
||
} finally {
|
||
request?.destroy()
|
||
response?.destroy()
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management state fan-out supports many tabs and releases every listener', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-state-fanout-'))
|
||
const coordinator = new Coordinator()
|
||
const server = createManagementServer({
|
||
coordinator,
|
||
logs: new JsonlLogManager({ root: join(root, 'logs') }),
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const connections = []
|
||
try {
|
||
for (let index = 0; index < 12; index += 1) {
|
||
connections.push(await new Promise((resolve, reject) => {
|
||
const request = httpRequest({ socketPath, path: `${API_PREFIX}events` }, response => {
|
||
response.once('data', () => resolve({ request, response }))
|
||
})
|
||
request.once('error', reject)
|
||
request.end()
|
||
}))
|
||
}
|
||
assert.equal(coordinator.getMaxListeners(), 0)
|
||
assert.equal(server.getMaxListeners(), 0)
|
||
assert.equal(coordinator.listenerCount('state'), 12)
|
||
assert.equal(server.listenerCount('management-state'), 12)
|
||
for (const connection of connections) {
|
||
connection.request.destroy()
|
||
connection.response.destroy()
|
||
}
|
||
for (let attempt = 0; attempt < 100 && coordinator.listenerCount('state') !== 0; attempt += 1) {
|
||
await new Promise(resolve => setTimeout(resolve, 5))
|
||
}
|
||
assert.equal(coordinator.listenerCount('state'), 0)
|
||
assert.equal(server.listenerCount('management-state'), 0)
|
||
} finally {
|
||
for (const connection of connections) {
|
||
connection.request.destroy()
|
||
connection.response.destroy()
|
||
}
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management reports unpublished development metadata without an HTTP error', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-unpublished-'))
|
||
const coordinator = new Coordinator()
|
||
coordinator.check = async () => ({ unavailable: true, upstream: { version: 'rc.10' } })
|
||
const server = createManagementServer({
|
||
coordinator,
|
||
logs: new JsonlLogManager({ root: join(root, 'logs') }),
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
try {
|
||
assert.deepEqual(await new LocalApiClient(socketPath).request('POST', '/_dsh_platform/api/v1/check'), {
|
||
available: false,
|
||
upstream: { version: 'rc.10' },
|
||
})
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management treats a page-open check during an update as an accepted no-op', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-busy-page-open-'))
|
||
const coordinator = new Coordinator()
|
||
coordinator.check = async () => ({ busy: true })
|
||
const server = createManagementServer({
|
||
coordinator,
|
||
logs: new JsonlLogManager({ root: join(root, 'logs') }),
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
try {
|
||
const response = await rawRequest(socketPath, `${API_PREFIX}check`, 'POST')
|
||
assert.equal(response.status, 202)
|
||
assert.deepEqual(JSON.parse(response.body), { busy: true })
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management edits only the fixed settings document with optimistic revisions', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-settings-document-'))
|
||
const dshHome = join(root, 'dsh')
|
||
const settingsDocument = new SettingsDocumentStore(dshHome)
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const server = createManagementServer({ coordinator: new Coordinator(), logs, settingsDocument })
|
||
const socketPath = join(root, 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
const empty = await client.request('GET', `${API_PREFIX}settings-document`)
|
||
assert.equal(empty.content, '')
|
||
assert.equal(empty.exists, false)
|
||
assert.match(empty.revision, /^[a-f0-9]{64}$/)
|
||
const saved = await client.request('PUT', `${API_PREFIX}settings-document`, {
|
||
content: 'language: zh\n', revision: empty.revision,
|
||
})
|
||
assert.equal(saved.exists, true)
|
||
assert.equal(await readFile(join(dshHome, 'settings.yaml'), 'utf8'), 'language: zh\n')
|
||
assert.equal((await lstat(join(dshHome, 'settings.yaml'))).isFile(), true)
|
||
await assert.rejects(client.request('PUT', `${API_PREFIX}settings-document`, {
|
||
content: 'language: en\n', revision: empty.revision, path: '/etc/passwd',
|
||
}), error => error.statusCode === 400)
|
||
await assert.rejects(client.request('PUT', `${API_PREFIX}settings-document`, {
|
||
content: 'language: en\n', revision: empty.revision,
|
||
}), error => error.statusCode === 409)
|
||
assert.equal(await readFile(join(dshHome, 'settings.yaml'), 'utf8'), 'language: zh\n')
|
||
assert.deepEqual((await logs.query({ sources: ['audit'] })).map(entry => entry.message), ['settings-document.saved'])
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('settings document editing rejects symbolic links, invalid UTF-8, and oversized content', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-settings-unsafe-'))
|
||
const dshHome = join(root, 'dsh')
|
||
await import('node:fs/promises').then(({ mkdir }) => mkdir(dshHome))
|
||
const target = join(root, 'outside.yaml')
|
||
await writeFile(target, 'outside: true\n')
|
||
await symlink(target, join(dshHome, 'settings.yaml'))
|
||
const store = new SettingsDocumentStore(dshHome, { maxBytes: 8 })
|
||
await assert.rejects(store.read(), /regular file/)
|
||
await import('node:fs/promises').then(({ rm }) => rm(join(dshHome, 'settings.yaml')))
|
||
await writeFile(join(dshHome, 'settings.yaml'), Buffer.from([0xc3, 0x28]))
|
||
await assert.rejects(store.read(), /not valid UTF-8/)
|
||
await assert.rejects(store.write('123456789', '0'.repeat(64)), /too large/)
|
||
assert.equal(await readFile(target, 'utf8'), 'outside: true\n')
|
||
})
|
||
|
||
test('management restarts only DSH as an audited task and excludes update activation', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-restart-'))
|
||
const coordinator = new Coordinator()
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
let finishRestart
|
||
const restartCompletion = new Promise(resolve => { finishRestart = resolve })
|
||
let finishLoadedStateCapture
|
||
const loadedStateCaptureCompletion = new Promise(resolve => { finishLoadedStateCapture = resolve })
|
||
let restarts = 0
|
||
let loadedStateCaptures = 0
|
||
const server = createManagementServer({
|
||
coordinator,
|
||
logs,
|
||
restartDelayMs: 0,
|
||
restartDsh: async () => {
|
||
restarts += 1
|
||
await restartCompletion
|
||
},
|
||
markUserPluginsLoaded: async () => {
|
||
loadedStateCaptures += 1
|
||
await loadedStateCaptureCompletion
|
||
},
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
const task = await client.request('POST', '/_dsh_platform/api/v1/restart-dsh')
|
||
assert.equal(typeof task.taskId, 'string')
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS && restarts === 0; attempt += 1) {
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(restarts, 1)
|
||
assert.equal((await client.request('GET', '/_dsh_platform/api/v1/status')).dshLifecycle.state, 'restarting')
|
||
await assert.rejects(
|
||
client.request('POST', '/_dsh_platform/api/v1/restart-dsh'),
|
||
error => error.statusCode === 409,
|
||
)
|
||
await assert.rejects(
|
||
client.request('POST', '/_dsh_platform/api/v1/update'),
|
||
error => error.statusCode === 409,
|
||
)
|
||
finishRestart()
|
||
await new Promise(resolve => setImmediate(resolve))
|
||
await logs.queue
|
||
const status = await client.request('GET', '/_dsh_platform/api/v1/status')
|
||
assert.equal(status.dshLifecycle.state, 'running')
|
||
assert.equal(status.dshLifecycle.taskId, task.taskId)
|
||
assert.equal(loadedStateCaptures, 1)
|
||
finishLoadedStateCapture()
|
||
assert.deepEqual(
|
||
(await logs.query({ sources: ['audit'] })).map(entry => entry.message),
|
||
['dsh.restart.started', 'dsh.restart.completed'],
|
||
)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management rejects DSH restart while an update task is active', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-restart-conflict-'))
|
||
const coordinator = new Coordinator()
|
||
coordinator.running = true
|
||
const server = createManagementServer({
|
||
coordinator,
|
||
logs: new JsonlLogManager({ root: join(root, 'logs') }),
|
||
restartDelayMs: 0,
|
||
restartDsh: async () => {},
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
try {
|
||
await assert.rejects(
|
||
new LocalApiClient(socketPath).request('POST', '/_dsh_platform/api/v1/restart-dsh'),
|
||
error => error.statusCode === 409,
|
||
)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management returns the restart task before the configured restart delay elapses', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-restart-delay-'))
|
||
let restarted = false
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs: new JsonlLogManager({ root: join(root, 'logs') }),
|
||
restartDelayMs: 40,
|
||
restartDsh: async () => { restarted = true },
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
const task = await client.request('POST', `${API_PREFIX}restart-dsh`)
|
||
assert.equal(typeof task.taskId, 'string')
|
||
assert.equal(restarted, false)
|
||
await new Promise(resolve => setTimeout(resolve, 60))
|
||
assert.equal(restarted, true)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management starts and stops DSH through the unified lifecycle state', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-lifecycle-'))
|
||
const calls = []
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs,
|
||
startDsh: async () => { calls.push('start') },
|
||
stopDsh: async () => { calls.push('stop') },
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
const stopped = await client.request('POST', `${API_PREFIX}stop-dsh`)
|
||
let status
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.dshLifecycle.taskId === stopped.taskId && status.dshLifecycle.state === 'stopped') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.dshLifecycle.state, 'stopped')
|
||
assert.equal(status.dshLifecycle.action, null)
|
||
|
||
const started = await client.request('POST', `${API_PREFIX}start-dsh`)
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.dshLifecycle.taskId === started.taskId && status.dshLifecycle.state === 'running') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.dshLifecycle.state, 'running')
|
||
assert.deepEqual(calls, ['stop', 'start'])
|
||
assert.deepEqual((await logs.query({ sources: ['audit'] })).map(entry => entry.message), [
|
||
'dsh.stop.started', 'dsh.stop.completed', 'dsh.start.started', 'dsh.start.completed',
|
||
])
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management preserves a completed lifecycle task until Bootstrap publishes a newer state', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-lifecycle-merge-'))
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
let bootstrapLifecycle = {
|
||
state: 'running', action: null, taskId: null, attempt: 0, maxAttempts: 3,
|
||
error: null, updatedAt: '2026-08-22T00:00:00.000Z',
|
||
}
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs,
|
||
platformStatus: async () => ({ dshLifecycle: bootstrapLifecycle }),
|
||
startDsh: async () => {},
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
const started = await client.request('POST', `${API_PREFIX}start-dsh`)
|
||
let status
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.dshLifecycle.taskId === started.taskId && status.dshLifecycle.state === 'running') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.dshLifecycle.taskId, started.taskId)
|
||
|
||
bootstrapLifecycle = {
|
||
...bootstrapLifecycle,
|
||
state: 'recovering', action: 'auto-recover', attempt: 1,
|
||
updatedAt: '2099-08-22T00:00:00.000Z',
|
||
}
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
assert.equal(status.dshLifecycle.state, 'recovering')
|
||
assert.equal(status.dshLifecycle.attempt, 1)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management resets the current Runtime as an audited exclusive task', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-runtime-reset-'))
|
||
const coordinator = new Coordinator()
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
let finishReset
|
||
const completion = new Promise(resolve => { finishReset = resolve })
|
||
let resets = 0
|
||
const server = createManagementServer({
|
||
coordinator,
|
||
logs,
|
||
resetRuntime: async () => {
|
||
resets += 1
|
||
await completion
|
||
},
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
const task = await client.request('POST', '/_dsh_platform/api/v1/runtime/reset')
|
||
assert.equal(typeof task.taskId, 'string')
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS && resets === 0; attempt += 1) {
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(resets, 1)
|
||
assert.equal((await client.request('GET', '/_dsh_platform/api/v1/status')).runtimeReset.status, 'resetting')
|
||
for (const path of ['runtime/reset', 'restart-dsh', 'update']) {
|
||
await assert.rejects(
|
||
client.request('POST', `/_dsh_platform/api/v1/${path}`),
|
||
error => error.statusCode === 409,
|
||
)
|
||
}
|
||
finishReset()
|
||
await new Promise(resolve => setImmediate(resolve))
|
||
await logs.queue
|
||
const status = await client.request('GET', '/_dsh_platform/api/v1/status')
|
||
assert.equal(status.runtimeReset.status, 'success')
|
||
assert.equal(status.runtimeReset.taskId, task.taskId)
|
||
assert.deepEqual(
|
||
(await logs.query({ sources: ['audit'] })).map(entry => entry.message),
|
||
['runtime.reset.started', 'runtime.reset.completed'],
|
||
)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management exposes recoverable User Plugin tasks under the shared runtime mutex', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-user-plugins-'))
|
||
const coordinator = new Coordinator()
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
let finish
|
||
const completion = new Promise(resolve => { finish = resolve })
|
||
const calls = []
|
||
const inventory = {
|
||
schema: 1,
|
||
profile: 'web',
|
||
revision: `sha256:${'a'.repeat(64)}`,
|
||
plugins: [{ name: 'faulty-plugin', enabled: true, damaged: false }],
|
||
}
|
||
const server = createManagementServer({
|
||
coordinator,
|
||
logs,
|
||
listUserPlugins: async () => inventory,
|
||
validateUserPluginActions: async value => {
|
||
calls.push(['validate', value])
|
||
if (value.revision !== inventory.revision) {
|
||
const error = new Error('revision changed')
|
||
error.code = 'REVISION_CONFLICT'
|
||
throw error
|
||
}
|
||
return value
|
||
},
|
||
applyUserPluginActions: async value => {
|
||
calls.push(['apply', value.taskId, value.revision, value.actions])
|
||
value.onProgress({ phase: 'paused' })
|
||
await completion
|
||
value.onProgress({ phase: 'completed' })
|
||
},
|
||
})
|
||
const socketPath = join(root, 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
assert.deepEqual(await client.request('GET', `${API_PREFIX}user-plugins`), inventory)
|
||
const request = {
|
||
profile: 'web', revision: inventory.revision,
|
||
actions: [{ name: 'faulty-plugin', action: 'disable' }],
|
||
}
|
||
const started = await client.request('POST', `${API_PREFIX}user-plugins/apply`, request)
|
||
assert.match(started.taskId, /^[0-9a-f-]{36}$/)
|
||
let status
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.userPluginOperation.phase === 'paused') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.userPluginOperation.status, 'running')
|
||
assert.equal(status.userPluginOperation.phase, 'paused')
|
||
assert.equal((await client.request('GET', `${API_PREFIX}user-plugins/task/${started.taskId}`)).status, 'running')
|
||
for (const [path, body] of [
|
||
['restart-dsh', undefined],
|
||
['update', undefined],
|
||
['bundled-plugins/action', { id: 'diagnostics', action: 'disable' }],
|
||
['user-plugins/apply', request],
|
||
]) {
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}${path}`, body), error => error.statusCode === 409)
|
||
}
|
||
finish()
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.userPluginOperation.status === 'success') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.userPluginOperation.phase, 'completed')
|
||
assert.equal((await client.request('GET', `${API_PREFIX}user-plugins/task/${started.taskId}`)).status, 'success')
|
||
assert.deepEqual(calls[0], ['validate', { revision: inventory.revision, actions: request.actions }])
|
||
assert.deepEqual(calls[1].slice(0, 3), ['apply', started.taskId, inventory.revision])
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}user-plugins/apply`, {
|
||
...request, revision: `sha256:${'b'.repeat(64)}`,
|
||
}), error => error.statusCode === 409)
|
||
await assert.rejects(
|
||
client.request('GET', `${API_PREFIX}user-plugins/task/123e4567-e89b-42d3-a456-426614174000`),
|
||
error => error.statusCode === 404,
|
||
)
|
||
await logs.queue
|
||
assert.deepEqual((await logs.query({ sources: ['audit'] })).map(entry => entry.message), [
|
||
'user-plugin.apply.started', 'user-plugin.apply.completed',
|
||
])
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management resumes a persisted User Plugin transaction after its socket is available', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-user-plugin-resume-'))
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
let recover
|
||
const recovery = new Promise(resolve => { recover = resolve })
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs,
|
||
recoverUserPluginTransaction: async () => recovery,
|
||
})
|
||
const socketPath = join(root, 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}restart-dsh`), error => error.statusCode === 409)
|
||
recover({
|
||
taskId: 'resume-task', phase: 'failed', error: 'interrupted change restored', recoveryResult: 'success',
|
||
})
|
||
let status
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.userPluginOperation.taskId === 'resume-task') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.userPluginOperation.status, 'failed')
|
||
assert.equal(status.userPluginOperation.error, 'interrupted change restored')
|
||
await logs.queue
|
||
assert.equal((await logs.query({ sources: ['audit'] })).at(-1).message, 'user-plugin.recovery.completed')
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('standalone Management disables a startup-faulting Bundle while DSH is already down', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-fault-plugin-'))
|
||
const dshHome = join(root, 'dsh')
|
||
const profileRoot = join(dshHome, 'profiles/web')
|
||
const pluginRoot = join(profileRoot, 'node_modules/startup-fault')
|
||
const selectionPath = join(root, 'platform/state/management/user-plugins.json')
|
||
await mkdir(pluginRoot, { recursive: true })
|
||
await writeFile(join(profileRoot, 'package.json'), JSON.stringify({
|
||
name: 'dsh-profile-web',
|
||
dependencies: { 'startup-fault': '1.0.0' },
|
||
dsh: { profile: { bundles: ['startup-fault'] } },
|
||
}))
|
||
await writeFile(join(profileRoot, 'pnpm-lock.yaml'), 'lockfileVersion: 9\n')
|
||
await writeFile(join(pluginRoot, 'package.json'), JSON.stringify({
|
||
name: 'startup-fault', version: '1.0.0', dsh: { bundle: { patch: './cordis.patch.yml' } },
|
||
}))
|
||
await writeFile(join(pluginRoot, 'cordis.patch.yml'), '- insert: [{ id: startup-fault, name: startup-fault }]\n')
|
||
const inventory = new UserPluginInventory({ dshHome, selectionPath })
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
let paused = 0
|
||
let restarted = 0
|
||
const transactions = new UserPluginTransactionManager({
|
||
inventory,
|
||
selectionStore: new UserPluginSelectionStore(selectionPath),
|
||
snapshots: new UserPluginSnapshots({ root: join(root, 'platform/store/snapshots/user-plugins'), profileRoot }),
|
||
journal: new UserPluginJournal(join(root, 'platform/state/management/user-plugin-transaction.json')),
|
||
pauseDsh: async () => { paused += 1 },
|
||
restartDelayMs: 0,
|
||
restartDsh: async () => {
|
||
restarted += 1
|
||
const manifest = JSON.parse(await readFile(join(profileRoot, 'package.json'), 'utf8'))
|
||
if (manifest.dsh.profile.bundles.includes('startup-fault')) throw new Error('startup-fault crashed DSH')
|
||
},
|
||
report: (message, fields) => logs.diagnostic('user-plugin-manager', message, fields),
|
||
})
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs,
|
||
platformStatus: async () => ({ recoveryMode: 'startup-fault crashed DSH' }),
|
||
listUserPlugins: () => inventory.read(),
|
||
validateUserPluginActions: value => transactions.validate(value),
|
||
applyUserPluginActions: value => transactions.apply(value),
|
||
})
|
||
const socketPath = join(root, 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
const listed = await client.request('GET', `${API_PREFIX}user-plugins`)
|
||
assert.deepEqual(listed.plugins.map(plugin => [plugin.name, plugin.enabled]), [['startup-fault', true]])
|
||
assert.equal((await client.request('GET', `${API_PREFIX}status`)).recoveryMode, 'startup-fault crashed DSH')
|
||
const task = await client.request('POST', `${API_PREFIX}user-plugins/apply`, {
|
||
profile: 'web', revision: listed.revision,
|
||
actions: [{ name: 'startup-fault', action: 'disable' }],
|
||
})
|
||
let state
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
state = await client.request('GET', `${API_PREFIX}user-plugins/task/${task.taskId}`)
|
||
if (state.status !== 'running') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(state.status, 'success')
|
||
assert.equal(state.strategy, 'next-start')
|
||
assert.equal(paused, 0)
|
||
assert.equal(restarted, 0)
|
||
const manifest = JSON.parse(await readFile(join(profileRoot, 'package.json'), 'utf8'))
|
||
assert.deepEqual(manifest.dsh.profile.bundles, [])
|
||
await logs.queue
|
||
assert.deepEqual((await logs.query({ sources: ['user-plugin-manager'] })).map(entry => entry.message), [
|
||
'user-plugin.transaction.started', 'user-plugin.transaction.completed',
|
||
])
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management changes a bundled plugin as an audited task and excludes runtime changes', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-plugin-action-'))
|
||
const coordinator = new Coordinator()
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
let finish
|
||
const completion = new Promise(resolve => { finish = resolve })
|
||
const calls = []
|
||
const server = createManagementServer({
|
||
coordinator,
|
||
logs,
|
||
listBundledPlugins: async () => [{ id: 'diagnostics', installed: true, enabled: true, protected: false }],
|
||
configureBundledPlugin: async (id, action) => {
|
||
calls.push([id, action])
|
||
await completion
|
||
},
|
||
restartDelayMs: 0,
|
||
restartDsh: async () => {},
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
assert.deepEqual((await client.request('GET', '/_dsh_platform/api/v1/bundled-plugins')).plugins, [{
|
||
id: 'diagnostics', installed: true, enabled: true, protected: false,
|
||
}])
|
||
const task = await client.request('POST', '/_dsh_platform/api/v1/bundled-plugins/action', {
|
||
id: 'diagnostics', action: 'disable',
|
||
})
|
||
assert.equal(typeof task.taskId, 'string')
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS && calls.length === 0; attempt += 1) {
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.deepEqual(calls, [['diagnostics', 'disable']])
|
||
assert.equal((await client.request('GET', '/_dsh_platform/api/v1/status')).systemPluginOperation.status, 'running')
|
||
assert.equal((await client.request('GET', `/_dsh_platform/api/v1/bundled-plugins/task/${task.taskId}`)).status, 'running')
|
||
await assert.rejects(
|
||
client.request('GET', '/_dsh_platform/api/v1/bundled-plugins/task/123e4567-e89b-42d3-a456-426614174000'),
|
||
error => error.statusCode === 404,
|
||
)
|
||
for (const [method, path, body] of [
|
||
['POST', '/_dsh_platform/api/v1/bundled-plugins/action', { id: 'diagnostics', action: 'uninstall' }],
|
||
['POST', '/_dsh_platform/api/v1/restart-dsh'],
|
||
['POST', '/_dsh_platform/api/v1/update'],
|
||
]) {
|
||
await assert.rejects(client.request(method, path, body), error => error.statusCode === 409)
|
||
}
|
||
finish()
|
||
await new Promise(resolve => setImmediate(resolve))
|
||
await logs.queue
|
||
const changed = await client.request('GET', '/_dsh_platform/api/v1/status')
|
||
assert.equal(changed.systemPluginOperation.status, 'success')
|
||
assert.equal(changed.systemPluginOperation.restartRequired, true)
|
||
assert.equal((await client.request('GET', `/_dsh_platform/api/v1/bundled-plugins/task/${task.taskId}`)).status, 'success')
|
||
assert.deepEqual(
|
||
(await logs.query({ sources: ['audit'] })).map(entry => entry.message),
|
||
['system-plugin.disable.started', 'system-plugin.disable.completed'],
|
||
)
|
||
await client.request('POST', '/_dsh_platform/api/v1/restart-dsh')
|
||
let restarted
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
restarted = await client.request('GET', '/_dsh_platform/api/v1/status')
|
||
if (restarted.dshLifecycle.state === 'running') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(restarted.dshLifecycle.state, 'running')
|
||
assert.equal(restarted.systemPluginOperation.restartRequired, false)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management completes System Plugin changes for the next start while DSH is unavailable', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-system-plugin-offline-'))
|
||
let configured = false
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs: new JsonlLogManager({ root: join(root, 'logs') }),
|
||
platformStatus: async () => ({
|
||
recoveryMode: 'startup failed',
|
||
dshLifecycle: { state: 'failed' },
|
||
}),
|
||
configureBundledPlugin: async () => { configured = true },
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
await client.request('POST', `${API_PREFIX}bundled-plugins/action`, {
|
||
id: 'diagnostics', action: 'disable',
|
||
})
|
||
let status
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.systemPluginOperation.status === 'success') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(configured, true)
|
||
assert.equal(status.systemPluginOperation.strategy, 'next-start')
|
||
assert.equal(status.systemPluginOperation.restartRequired, false)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management toggle endpoint accepts only enable and disable actions', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-plugin-toggle-'))
|
||
const calls = []
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs: new JsonlLogManager({ root: join(root, 'logs') }),
|
||
configureBundledPlugin: async (id, action) => { calls.push([id, action]) },
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}bundled-plugins/toggle`, {
|
||
id: 'diagnostics', action: 'install',
|
||
}), error => error.statusCode === 400)
|
||
const task = await client.request('POST', `${API_PREFIX}bundled-plugins/toggle`, {
|
||
id: 'diagnostics', action: 'disable',
|
||
})
|
||
assert.equal(typeof task.taskId, 'string')
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS && calls.length === 0; attempt += 1) {
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.deepEqual(calls, [['diagnostics', 'disable']])
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management discards unapplied System Plugin changes and clears restart state', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-plugin-discard-'))
|
||
let discarded = 0
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs,
|
||
configureBundledPlugin: async () => {},
|
||
discardBundledPluginChanges: async () => {
|
||
discarded += 1
|
||
return { plugins: [{ id: 'diagnostics', pendingRestart: false }] }
|
||
},
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
await client.request('POST', `${API_PREFIX}bundled-plugins/action`, {
|
||
id: 'diagnostics', action: 'disable',
|
||
})
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
if ((await client.request('GET', `${API_PREFIX}status`)).systemPluginOperation.restartRequired) break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
let result
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
try {
|
||
result = await client.request('POST', `${API_PREFIX}bundled-plugins/discard`)
|
||
break
|
||
} catch (error) {
|
||
if (error.statusCode !== 409) throw error
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
}
|
||
assert.notEqual(result, undefined)
|
||
assert.equal(discarded, 1)
|
||
assert.deepEqual(result, { plugins: [{ id: 'diagnostics', pendingRestart: false }] })
|
||
assert.equal((await client.request('GET', `${API_PREFIX}status`)).systemPluginOperation.restartRequired, false)
|
||
assert.deepEqual((await logs.query({ sources: ['audit'] })).map(entry => entry.message), [
|
||
'system-plugin.disable.started',
|
||
'system-plugin.disable.completed',
|
||
'system-plugin.changes.discarded',
|
||
])
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management completes the System Plugin change when DSH restart fails', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-plugin-restart-failure-'))
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs,
|
||
configureBundledPlugin: async () => {},
|
||
restartDelayMs: 0,
|
||
restartDsh: async () => { throw new Error('restart failed') },
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
await client.request('POST', '/_dsh_platform/api/v1/bundled-plugins/action', {
|
||
id: 'diagnostics', action: 'disable',
|
||
})
|
||
let status
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', '/_dsh_platform/api/v1/status')
|
||
if (status.systemPluginOperation.status === 'success') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.systemPluginOperation.restartRequired, true)
|
||
await client.request('POST', '/_dsh_platform/api/v1/restart-dsh')
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', '/_dsh_platform/api/v1/status')
|
||
if (status.dshLifecycle.state === 'failed') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(status.dshLifecycle.state, 'failed')
|
||
assert.equal(status.systemPluginOperation.strategy, 'next-start')
|
||
assert.equal(status.systemPluginOperation.activationError, 'restart failed')
|
||
assert.equal(status.systemPluginOperation.restartRequired, false)
|
||
await logs.queue
|
||
assert.equal((await logs.query({ sources: ['audit'] })).find(entry => entry.message === 'dsh.restart.failed').level, 'error')
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management audit failures do not block a completed System Plugin operation', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-audit-failure-'))
|
||
let configured = false
|
||
const logs = {
|
||
diagnostic: () => { throw new Error('audit storage unavailable') },
|
||
query: async () => [],
|
||
on: () => {},
|
||
off: () => {},
|
||
}
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs,
|
||
configureBundledPlugin: async () => { configured = true },
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
await client.request('POST', `${API_PREFIX}bundled-plugins/action`, {
|
||
id: 'diagnostics', action: 'disable',
|
||
})
|
||
let status
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS; attempt += 1) {
|
||
status = await client.request('GET', `${API_PREFIX}status`)
|
||
if (status.systemPluginOperation.status === 'success') break
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.equal(configured, true)
|
||
assert.equal(status.systemPluginOperation.status, 'success')
|
||
assert.equal(status.systemPluginOperation.restartRequired, true)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management exposes a dedicated recovery action only for Platform Management', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-plugin-recovery-'))
|
||
const calls = []
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const server = createManagementServer({
|
||
coordinator: new Coordinator(),
|
||
logs,
|
||
recoverBundledPlugin: async (id, action) => { calls.push([id, action]) },
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
await assert.rejects(client.request('POST', `${API_PREFIX}bundled-plugins/recovery-action`, {
|
||
id: 'diagnostics', action: 'uninstall',
|
||
}), error => error.statusCode === 400)
|
||
const task = await client.request('POST', `${API_PREFIX}bundled-plugins/recovery-action`, {
|
||
id: 'platform-management', action: 'disable',
|
||
})
|
||
assert.equal(typeof task.taskId, 'string')
|
||
for (let attempt = 0; attempt < ASYNC_POLL_ATTEMPTS && calls.length === 0; attempt += 1) {
|
||
await new Promise(resolve => setTimeout(resolve, ASYNC_POLL_INTERVAL_MS))
|
||
}
|
||
assert.deepEqual(calls, [['platform-management', 'disable']])
|
||
await new Promise(resolve => setImmediate(resolve))
|
||
await logs.queue
|
||
assert.deepEqual(
|
||
(await logs.query({ sources: ['audit'] })).map(entry => entry.message),
|
||
['system-plugin.recovery.disable.started', 'system-plugin.recovery.disable.completed'],
|
||
)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management separates a known Stable target from update availability', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-current-'))
|
||
const coordinator = new Coordinator()
|
||
coordinator.check = async () => ({
|
||
value: { targetSequence: 2, desired: { dsh: { version: 'rc.7' } } },
|
||
updateAvailable: false,
|
||
})
|
||
const server = createManagementServer({
|
||
coordinator,
|
||
logs: new JsonlLogManager({ root: join(root, 'logs') }),
|
||
})
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
try {
|
||
assert.deepEqual(await new LocalApiClient(socketPath).request('POST', '/_dsh_platform/api/v1/check'), {
|
||
available: false,
|
||
targetSequence: 2,
|
||
desired: { dsh: { version: 'rc.7' } },
|
||
})
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management records a completion audit for a successful update task', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-audit-'))
|
||
const coordinator = new Coordinator()
|
||
coordinator.startReconcile = () => ({ taskId: 'task-success', completion: Promise.resolve() })
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const server = createManagementServer({ coordinator, logs })
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
try {
|
||
const client = new LocalApiClient(socketPath)
|
||
await client.request('POST', '/_dsh_platform/api/v1/update')
|
||
await new Promise(resolve => setImmediate(resolve))
|
||
await logs.queue
|
||
assert.deepEqual(
|
||
(await logs.query({ sources: ['audit'] })).map(entry => [entry.message, entry.taskId]),
|
||
[['update.started', 'task-success'], ['update.completed', 'task-success']],
|
||
)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management records correlated rollback and return-stable audit lifecycles', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-rollback-audit-'))
|
||
const coordinator = new Coordinator()
|
||
coordinator.startCompleteRollback = (planId, options) => {
|
||
assert.equal(planId, 'plan-a')
|
||
if (options.requireConfirmation) {
|
||
return { taskId: 'return-stable-failure', completion: Promise.reject(new Error('restore failed')) }
|
||
}
|
||
return { taskId: 'rollback-success', completion: Promise.resolve() }
|
||
}
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const server = createManagementServer({ coordinator, logs })
|
||
const socketPath = join(root, 'run', 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
try {
|
||
const client = new LocalApiClient(socketPath)
|
||
await client.request('POST', `${API_PREFIX}rollback`, { planId: 'plan-a' })
|
||
await client.request('POST', `${API_PREFIX}return-stable`, {
|
||
planId: 'plan-a', confirmDataLoss: true,
|
||
})
|
||
await new Promise(resolve => setImmediate(resolve))
|
||
await logs.queue
|
||
assert.deepEqual(
|
||
(await logs.query({ sources: ['audit'] })).map(entry => [entry.message, entry.taskId]),
|
||
[
|
||
['rollback.started', 'rollback-success'],
|
||
['rollback.completed', 'rollback-success'],
|
||
['return-stable.started', 'return-stable-failure'],
|
||
['return-stable.failed', 'return-stable-failure'],
|
||
],
|
||
)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('management serves only the fixed persistent Platform Management assets', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-console-'))
|
||
const coordinator = new Coordinator()
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
const server = createManagementServer({ coordinator, logs })
|
||
const socketPath = join(root, 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
try {
|
||
const redirect = await rawRequest(socketPath, '/_dsh_platform/console')
|
||
assert.equal(redirect.status, 308)
|
||
assert.equal(redirect.headers.location, '/_dsh_platform/console/')
|
||
const page = await rawRequest(socketPath, '/_dsh_platform/console/')
|
||
assert.equal(page.status, 200)
|
||
assert.match(page.headers['content-type'], /^text\/html/)
|
||
assert.match(page.body.toString('utf8'), /<link rel="icon" href="data:image\/svg\+xml,/)
|
||
assert.match(page.headers['content-security-policy'], /script-src 'self'/)
|
||
assert.match(page.headers['content-security-policy'], /connect-src 'self' http: https:/)
|
||
assert.match(page.body, /DSH Management Console/)
|
||
const script = await rawRequest(socketPath, '/_dsh_platform/console/app.js')
|
||
assert.equal(script.status, 200)
|
||
assert.match(script.body, /new EventSource/)
|
||
const themeInit = await rawRequest(socketPath, '/_dsh_platform/console/theme-init.js')
|
||
assert.equal(themeInit.status, 200)
|
||
assert.match(themeInit.headers['content-type'], /^text\/javascript/)
|
||
assert.match(themeInit.body, /console-theme/)
|
||
const head = await rawRequest(socketPath, '/_dsh_platform/console/style.css', 'HEAD')
|
||
assert.equal(head.status, 200)
|
||
assert.equal(head.body, '')
|
||
const xterm = await rawRequest(socketPath, '/_dsh_platform/console/vendor/xterm.mjs')
|
||
assert.equal(xterm.status, 200)
|
||
assert.match(xterm.headers['content-type'], /^text\/javascript/)
|
||
assert.match(xterm.body, /export\{/)
|
||
const fit = await rawRequest(socketPath, '/_dsh_platform/console/vendor/addon-fit.mjs')
|
||
assert.equal(fit.status, 200)
|
||
assert.match(fit.body, /FitAddon/)
|
||
assert.match((await rawRequest(socketPath, '/_dsh_platform/console/vendor/xterm.css')).headers['content-type'], /^text\/css/)
|
||
assert.equal((await rawRequest(socketPath, '/_dsh_platform/console/vendor/xterm.mjs.map')).status, 404)
|
||
assert.equal((await rawRequest(socketPath, '/_dsh_platform/console/../server.mjs')).status, 404)
|
||
assert.equal((await rawRequest(socketPath, '/_dsh_platform/console/app.js', 'POST')).status, 405)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|
||
|
||
test('Platform Management script references only DOM IDs declared by its document', async () => {
|
||
const publicRoot = new URL('../../control-plane/services/management/public/', import.meta.url)
|
||
const html = await readFile(new URL('index.html', publicRoot), 'utf8')
|
||
const script = await readFile(new URL('app.js', publicRoot), 'utf8')
|
||
const ids = new Set([...html.matchAll(/\bid="([a-z0-9-]+)"/g)].map(match => match[1]))
|
||
const references = [...script.matchAll(/elements(?:\.([A-Za-z][A-Za-z0-9]*)|\[['"]([a-z0-9-]+)['"]\])/g)]
|
||
.map(match => match[1] ?? match[2])
|
||
assert.equal(references.length > 0, true)
|
||
for (const id of references) assert.equal(ids.has(id), true, `Console element ${id} is not declared`)
|
||
assert.doesNotMatch(script, /innerHTML|outerHTML|insertAdjacentHTML/)
|
||
assert.match(script, /selectTab\(window\.location\.hash === '#auth-settings' \? 'auth-settings' : 'maintenance'\)/)
|
||
})
|
||
|
||
test('standalone file task queue stays below file actions and scrolls within a fixed height', async () => {
|
||
const publicRoot = new URL('../../control-plane/services/management/public/', import.meta.url)
|
||
const html = await readFile(new URL('index.html', publicRoot), 'utf8')
|
||
const script = await readFile(new URL('app.js', publicRoot), 'utf8')
|
||
const style = await readFile(new URL('style.css', publicRoot), 'utf8')
|
||
const browserOffset = html.indexOf('class="file-browser"')
|
||
const selectionOffset = html.indexOf('class="file-selection"')
|
||
const taskOffset = html.indexOf('id="file-task-state"')
|
||
const archiveOffset = html.indexOf('id="file-archive-panel"')
|
||
assert.equal(browserOffset < selectionOffset && selectionOffset < taskOffset && taskOffset < archiveOffset, true)
|
||
assert.match(style, /\.file-task-list\s*\{[^}]*max-height:\s*180px;[^}]*overflow-y:\s*auto;/)
|
||
assert.match(style, /\.file-main\s*\{[^}]*display:\s*flex;[^}]*flex-direction:\s*column;/)
|
||
assert.match(style, /\.file-pagination\s*\{[^}]*margin-top:\s*auto;/)
|
||
assert.match(script, /task\.status === 'failed' && Date\.parse\(task\.updatedAt\) >= recentCutoff/)
|
||
assert.doesNotMatch(script, /\['success', 'failed', 'cancelled'\]/)
|
||
assert.match(script, /fileUploadQueue = files\.map/)
|
||
assert.match(script, /request\.upload\.onprogress/)
|
||
assert.match(script, /\.\.\.fileUploadQueue, \.\.\.backend/)
|
||
assert.match(script, /task\.local === true\) task\.cancel\(\)/)
|
||
assert.match(script, /item\.webkitGetAsEntry\?\.\(\)/)
|
||
assert.match(script, /collectDroppedEntry\(child, relativePath\)/)
|
||
assert.match(script, /fileDropTarget\.addEventListener\('drop'/)
|
||
assert.match(html, /class="file-drop-overlay"/)
|
||
assert.match(style, /\.file-main\.file-dragging \.file-drop-overlay\s*\{[^}]*display:\s*grid;/)
|
||
assert.match(style, /\.proxy-provider-list \{[^}]*max-height: 320px;[^}]*overflow-y: auto;/)
|
||
assert.match(html, /id="proxy-advanced"[\s\S]*id="proxy-remote-dns-row"[^>]*hidden[\s\S]*id="proxy-remote-dns"/)
|
||
assert.doesNotMatch(style, /\.proxy-check-row/)
|
||
assert.match(style, /\.proxy-scope-description \{[^}]*-webkit-line-clamp: 1;/)
|
||
assert.match(script, /function refreshProxyDescriptions\(\)[\s\S]*preserveScrollableAncestors/)
|
||
assert.match(script, /function renderProxyProviders\(\)[\s\S]*displayName[\s\S]*info\.className = 'proxy-provider-info'/)
|
||
assert.match(script, /proxyConfiguration = await api\('proxy'\)[\s\S]*renderProxyConfiguration\(\)[\s\S]*void refreshProxyProviders\(\)/)
|
||
assert.match(script, /if \(tab === 'proxy'\) \{[\s\S]*if \(proxyLoaded\) void refreshProxyProviders\(\)[\s\S]*else void loadProxy\(\)/)
|
||
assert.match(script, /function refreshVisibleProxyProviders\(\)[\s\S]*proxyLoaded[\s\S]*panel-proxy[\s\S]*refreshProxyProviders\(\)/)
|
||
assert.match(script, /window\.addEventListener\('focus', refreshVisibleProxyProviders\)/)
|
||
assert.doesNotMatch(script, /Promise\.all\(\[api\('proxy'\), api\('proxy\/provider-inventory'\)\]\)/)
|
||
assert.match(script, /proxy-provider-search[\s\S]*addEventListener\('input', renderProxyProviders\)/)
|
||
assert.match(script, /proxy-clear-password[\s\S]*getAttribute\('aria-pressed'\) === 'true'/)
|
||
assert.match(script, /route\.className = 'proxy-provider-route'[\s\S]*input\.dataset\.providerPolicy = provider\.id[\s\S]*input\.checked = policy\.proxyEnabled === true/)
|
||
assert.match(html, /class="proxy-scope-card"[\s\S]*class="toggle"[\s\S]*data-proxy-scope="updates"/)
|
||
assert.match(html, /id="proxy-clear-password"[^>]*aria-pressed="false"/)
|
||
assert.match(html, /class="proxy-setting-row[^"]*"[\s\S]*class="toggle"[\s\S]*id="proxy-all-proxy"/)
|
||
assert.match(html, /id="proxy-provider-search"[^>]*type="search"/)
|
||
assert.match(html, /id="proxy-test-dialog"[\s\S]*id="proxy-test-stages"/)
|
||
assert.doesNotMatch(html, /id="proxy-test-close"/)
|
||
assert.match(html, /<footer><p id="proxy-test-result"[\s\S]*<button id="proxy-test-cancel"/)
|
||
assert.match(html, /class="proxy-setting-row[^"]*"[\s\S]*id="proxy-enabled"/)
|
||
assert.ok(html.indexOf('id="proxy-master-title"') < html.indexOf('id="proxy-title"'))
|
||
assert.ok(html.indexOf('id="proxy-enabled"') < html.indexOf('id="proxy-test"'))
|
||
assert.match(html, /<h2 id="proxy-master-title"[^>]*>[\s\S]*id="proxy-component-alert"[^>]*hidden/)
|
||
assert.match(html, /<path d="M12 6\.5v7"\/><path d="M12 17\.5h\.01"\/>/)
|
||
assert.match(html, /id="proxy-component-dialog"[\s\S]*proxyComponentIssueDetail/)
|
||
assert.match(style, /\.proxy-master-row > div > small \{ font-size: 13px; line-height: 20px; \}/)
|
||
assert.match(style, /\.proxy-advanced-setting > div > small \{ font-size: 13px; line-height: 20px; \}/)
|
||
assert.match(html, /<h3 data-i18n="proxyRules"[\s\S]*<h3 data-i18n="proxyAllProxy"/)
|
||
assert.doesNotMatch(html, /<span data-i18n="proxyDirectRules"/)
|
||
assert.match(style, /\.proxy-test-stage > span:nth-child\(2\) \{[^}]*display: grid;[^}]*gap: 1px;/)
|
||
assert.match(style, /\.proxy-test-dialog footer \{[^}]*display: grid;[^}]*grid-template-columns: minmax\(0, 1fr\) auto;/)
|
||
assert.match(style, /\.proxy-test-dialog footer > \.operation-result \{[^}]*margin: 0;/)
|
||
assert.doesNotMatch(style, /@media \(max-width: 640px\)[\s\S]*\.proxy-test-dialog \{[^}]*height: 100dvh;/)
|
||
assert.match(style, /\.proxy-scope-dialog \{[^}]*height: min\(760px, calc\(100dvh - 32px\)\)/)
|
||
assert.match(style, /\.proxy-scope-catalog \{[^}]*min-height: 0;[^}]*overflow: auto;/)
|
||
assert.match(script, /detail\.className = 'proxy-scope-description'[\s\S]*refreshProxyDescriptions\(\)/)
|
||
assert.match(script, /function pendingProxyTestStages\(proxy = \{\}\)[\s\S]*stage !== 'target-dns'[\s\S]*proxy\.protocol === 'socks5'[\s\S]*status: 'pending'/)
|
||
assert.match(script, /async function startProxyTest\(\)[\s\S]*status: 'starting'[\s\S]*pendingProxyTestStages\(\{[\s\S]*protocol:[\s\S]*remoteDns:[\s\S]*showModal\(\)/)
|
||
assert.match(script, /function failedProxyTest\(error,[\s\S]*pendingProxyTestStages\(\)/)
|
||
assert.match(script, /const expandedProxyTestStages = new Set\(\)/)
|
||
assert.match(script, /item\.setAttribute\('role', 'button'\)[\s\S]*item\.setAttribute\('aria-expanded'[\s\S]*preserveScrollableAncestors\(item[\s\S]*detail\.hidden = !expanded/)
|
||
assert.match(script, /statusLabel\.textContent = status/)
|
||
assert.match(script, /proxy-test-cancel'[\s\S]*textContent = t\(running \? 'cancel' : 'close'\)/)
|
||
assert.match(script, /proxy-enabled'[\s\S]*saveProxyImmediate\(configuration => \{ configuration\.enabled = event\.target\.checked \}\)/)
|
||
assert.doesNotMatch(script, /proxy-enabled-label|proxy-test-close/)
|
||
assert.match(html, /id="proxy-title"[\s\S]*id="proxy-test"[\s\S]*id="proxy-save"/)
|
||
assert.match(html, /id="proxy-advanced-toggle"[^>]*aria-controls="proxy-advanced"[\s\S]*id="proxy-advanced"[\s\S]*id="proxy-system-rules"[\s\S]*id="proxy-direct-rules"[\s\S]*id="proxy-all-proxy"[\s\S]*id="proxy-remote-dns-row"/)
|
||
assert.doesNotMatch(html, /id="proxy-rules-save"|id="proxy-password-state"|id="proxy-operation-result"/)
|
||
assert.doesNotMatch(html, /<section aria-labelledby="proxy-test-title">/)
|
||
assert.match(html, /id="proxy-provider-info-dialog"[\s\S]*id="proxy-provider-info-detail"/)
|
||
assert.match(script, /proxy-provider-info-dialog[\s\S]*event\.target === event\.currentTarget[\s\S]*\.close\(\)/)
|
||
assert.match(script, /function splitDirectRules\(value\)[\s\S]*noProxy:[\s\S]*bypass:/)
|
||
assert.match(html, /id="proxy-direct-rules"/)
|
||
assert.match(html, /id="proxy-system-rules-dialog"[\s\S]*id="proxy-system-rules-list"/)
|
||
assert.doesNotMatch(html, /id="proxy-no-proxy"|id="proxy-bypass"/)
|
||
assert.doesNotMatch(style, /\.proxy-provider-description/)
|
||
assert.match(html, /class="log-summary-row"><p id="log-summary"[\s\S]*id="auto-scroll" type="checkbox" checked/)
|
||
assert.match(style, /\.log-auto-scroll \{[^}]*margin-left: auto;/)
|
||
assert.match(script, /operationState === 'success' \|\| operation\?\.state === 'running'/)
|
||
assert.match(script, /visibleOperationTasks\.delete\(taskId\)[\s\S]*3_000/)
|
||
assert.match(script, /fileOperationTimer = window\.setTimeout\(\(\) => fileOperationMessage\(''\), 3_000\)/)
|
||
assert.match(html, /id="file-editor-status" role="status" aria-live="polite"/)
|
||
assert.match(script, /function renderFileEditorState\(\)[\s\S]*fileEditorSaving[\s\S]*fileEditorDirty/)
|
||
assert.match(script, /const content = elements\['file-editor-content'\]\.value[\s\S]*body: \{ path, content, revision, create \}[\s\S]*fileEditorDirty = elements\['file-editor-content'\]\.value !== fileEditorOriginal/)
|
||
assert.match(style, /\.file-editor-footer \{[^}]*justify-content: space-between;/)
|
||
assert.match(style, /@media \(max-width: 640px\)[\s\S]*\.plugin-draft-actions \{ display: grid; width: 100%; grid-template-columns: 1fr; \}/)
|
||
})
|
||
|
||
test('standalone console keeps localized feature parity on the shared Management API', async () => {
|
||
const publicRoot = new URL('../../control-plane/services/management/public/', import.meta.url)
|
||
const html = await readFile(new URL('index.html', publicRoot), 'utf8')
|
||
const script = await readFile(new URL('app.js', publicRoot), 'utf8')
|
||
const style = await readFile(new URL('style.css', publicRoot), 'utf8')
|
||
const serverSource = await readFile(new URL('../../control-plane/services/management/server.mjs', import.meta.url), 'utf8')
|
||
const maintenanceSource = await readFile(new URL('../stage0/lib/maintenance-server.mjs', import.meta.url), 'utf8')
|
||
const pluginSource = await readFile(new URL('../../environment/resources/plugins/platform-management/package/lib/client.js', import.meta.url), 'utf8')
|
||
for (const panel of ['updates', 'proxy', 'auth-settings', 'maintenance', 'plugins', 'skills', 'user-skills', 'user-plugins', 'terminal', 'files']) {
|
||
assert.match(html, new RegExp(`id="panel-${panel}"`))
|
||
}
|
||
const extensionTabs = [
|
||
'tab-maintenance', 'tab-files', 'tab-terminal', 'tab-plugins',
|
||
'tab-skills', 'tab-user-plugins', 'tab-user-skills', 'tab-proxy', 'tab-updates', 'tab-auth-settings',
|
||
]
|
||
.map(id => html.indexOf(`id="${id}"`))
|
||
assert.deepEqual(extensionTabs, [...extensionTabs].sort((left, right) => left - right))
|
||
assert.match(html, /id="tab-maintenance"[^>]*aria-selected="true"/)
|
||
assert.match(html, /id="panel-maintenance"[^>]*aria-labelledby="tab-maintenance">/)
|
||
assert.match(html, /id="panel-updates"[^>]*hidden>/)
|
||
assert.match(script, /void selectTab\('maintenance'\)/)
|
||
for (const route of [
|
||
'status', 'check', 'update', 'channel', 'automatic-check', 'holds/retry', 'rollback',
|
||
'return-stable', 'start-dsh', 'stop-dsh', 'restart-dsh', 'runtime/reset', 'bundled-plugins', 'bundled-plugins/recovery-action',
|
||
'bundled-plugins/discard', 'system-skills', 'system-skills/action', 'user-skills', 'user-skills/action', 'user-plugins', 'user-plugins/apply', 'user-plugins/task/', 'logs/stream',
|
||
'terminal/sessions',
|
||
'files/config', 'files/list', 'files/content', 'files/upload', 'files/download', 'files/tasks',
|
||
'proxy/provider-inventory', 'proxy/test', 'proxy/test/tasks/',
|
||
]) assert.match(script, new RegExp(route.replace('/', '\\/')))
|
||
assert.match(script, /const COPY = Object\.freeze\(\{[\s\S]*zh:[\s\S]*en:/)
|
||
assert.match(script, /projected\.enabled \? t\('userPluginEnabled'\) : t\('userPluginDisabled'\)/)
|
||
assert.match(script, /skill\.enabled \? t\('userSkillEnabled'\) : t\('userSkillDisabled'\)/)
|
||
assert.match(script, /dialogFocusTriggers = new WeakMap/)
|
||
assert.match(script, /dialogOpenObserver = new MutationObserver/)
|
||
assert.match(html, /<select id="language-switch"[^>]*data-i18n-aria-label="switchLanguage"/)
|
||
assert.match(html, /<option value="zh">中文<\/option>[\s\S]*<option value="en">English<\/option>/)
|
||
assert.match(html, /<script src="\.\/theme-init\.js"><\/script>[\s\S]*<link rel="stylesheet" href="\.\/style\.css">/)
|
||
assert.match(html, /<button id="theme-switch" class="theme-switch"[^>]*>[\s\S]*data-theme-icon="system"[\s\S]*data-theme-icon="light"[\s\S]*data-theme-icon="dark"/)
|
||
assert.equal((html.match(/class="theme-icon"[^>]*>[\s\S]*?<svg viewBox="0 0 24 24">/g) ?? []).length, 3)
|
||
assert.match(script, /LANGUAGE_KEY = 'dsh-platform:console-language'/)
|
||
assert.match(script, /THEME_KEY = 'dsh-platform:console-theme'/)
|
||
assert.match(script, /fetch\(`\$\{managementLoginPath\(\)\}\/session-context`/)
|
||
assert.match(html, /id="auth-isolation-compare"[\s\S]*id="auth-root-warning"[\s\S]*id="auth-mode"/)
|
||
assert.doesNotMatch(html, /authRuntimeTitle|auth-agent-warning/)
|
||
assert.match(html, /<form id="auth-settings-form" class="auth-settings-form" method="post" action="" novalidate>/)
|
||
assert.match(html, /data-i18n="authMainPasswordTitle">Administrator account<\/h3><button id="auth-account-save"[^>]+data-i18n="authSaveApply"/)
|
||
assert.match(html, /id="auth-account-save"[\s\S]*id="auth-username"[\s\S]*id="auth-current-password"/)
|
||
assert.match(html, /data-i18n="authOriginTitle">Management origin<\/h3>[\s\S]*id="auth-origin-save"[^>]+data-i18n="authSaveApply"/)
|
||
assert.match(html, /id="auth-origin-settings" hidden>[\s\S]*id="auth-origin" type="url"[\s\S]*id="auth-local-port" type="number" min="1" max="65535" step="1" inputmode="numeric" value="3081"[\s\S]*id="auth-origin-detect"/)
|
||
assert.doesNotMatch(html, /Compatibility path \(3080\)/)
|
||
assert.doesNotMatch(html, /id="auth-settings-save"/)
|
||
assert.match(html, /class="auth-additional-heading"[^>]*>[\s\S]*data-i18n="authAdditionalTitle"[\s\S]*class="toggle"[^>]*data-i18n-aria-label="authAdditionalEnabled"[\s\S]*id="auth-additional-enabled"/)
|
||
assert.match(html, /class="auth-two-factor auth-additional-heading"[^>]*>[\s\S]*data-i18n="authTotpTitle"[\s\S]*id="auth-totp-enabled"/)
|
||
assert.ok(html.indexOf('id="auth-totp-enabled"') < html.indexOf('id="auth-additional-enabled"'))
|
||
assert.doesNotMatch(html, /id="auth-totp-fields"/)
|
||
assert.match(html, /id="auth-totp-dialog"[\s\S]*id="auth-totp-qr"[\s\S]*id="auth-totp-secret-toggle"[\s\S]*id="auth-totp-code"[\s\S]*id="auth-totp-confirm"/)
|
||
assert.doesNotMatch(html, /id="auth-current-additional-password"/)
|
||
assert.match(html, /id="auth-additional-fields" class="auth-password-grid" hidden/)
|
||
assert.doesNotMatch(html, />Require an additional password for Management</)
|
||
assert.match(html, /id="auth-session-list" class="auth-session-list"/)
|
||
assert.doesNotMatch(html, /auth-revoke-(?:other|all)-(?:dsh|management)/)
|
||
assert.match(style, /\.auth-settings-form \{ display: grid; width: 100%; gap: 16px; \}/)
|
||
assert.match(style, /\.auth-password-grid \{[^}]*align-items: start;/)
|
||
assert.doesNotMatch(style, /\.auth-settings-form \{[^}]*max-width:/)
|
||
assert.match(style, /\.auth-session-revoke \{[^}]*color: var\(--danger\);/)
|
||
assert.match(script, /body: \{ sessionId: button\.dataset\.sessionId \}/)
|
||
assert.match(html, /id="auth-username"[^>]+pattern="\[\^\\p\{Cc\}/)
|
||
assert.match(html, /id="auth-username-error"[^>]+data-i18n="authUsernameFormat"[^>]+hidden/)
|
||
assert.match(html, /id="auth-current-password"[^>]+maxlength="1024"/)
|
||
assert.doesNotMatch(html, /id="auth-current-password"[^>]+minlength=/)
|
||
for (const id of ['auth-password', 'auth-password-confirm', 'auth-additional-password', 'auth-additional-password-confirm']) {
|
||
assert.match(html, new RegExp(`id="${id}"[^>]+minlength="8"[^>]+pattern="\\[\\^\\\\p\\{Cc\\}`))
|
||
assert.match(html, new RegExp(`id="${id}-error"[^>]+data-i18n="authPasswordFormat"[^>]+hidden`))
|
||
}
|
||
assert.match(script, /function validateAuthenticationSettingsFormat\(\)/)
|
||
assert.match(script, /function validatePasswordConfirmation\(passwordId, confirmationId\)/)
|
||
assert.match(script, /function authenticationAccountDraft\(\)/)
|
||
assert.match(script, /function validateCurrentPassword\(draft/)
|
||
assert.match(script, /function renderAuthenticationAccountSaveState\(\)/)
|
||
assert.match(script, /await api\('auth-totp\/enrollments'/)
|
||
assert.match(script, /disabling \? 'auth-totp\/disable-confirmations\/confirm' : 'auth-totp\/enrollments\/confirm'/)
|
||
assert.match(script, /disabling \? 'auth-totp\/disable-confirmations\/cancel' : 'auth-totp\/enrollments\/cancel'/)
|
||
assert.match(script, /await api\(disabling \? 'auth-totp\/disable-confirmations\/confirm'/)
|
||
assert.match(script, /function showTotpRetryCountdown\(error\)/)
|
||
assert.match(script, /body\.totpEnabled = false[\s\S]*body\.totpDisableConfirmationToken = pendingTotpChange\.confirmation\.confirmationToken/)
|
||
assert.match(script, /body\.totpEnabled = true[\s\S]*body\.totpEnrollmentToken = pendingTotpChange\.enrollment\.enrollmentToken/)
|
||
assert.match(script, /pending\.confirmed = true[\s\S]*showAuthenticationStatus\(t\('authTotpConfirmedDraft'\)\)/)
|
||
assert.match(script, /elements\['auth-totp-enabled'\]\.addEventListener\('change',[\s\S]*changeTotpEnabled/)
|
||
assert.match(script, /function trapTotpDialogFocus\(event\)[\s\S]*event\.key !== 'Tab'[\s\S]*elements\['auth-totp-dialog'\]\.addEventListener\('keydown', trapTotpDialogFocus\)/)
|
||
assert.match(script, /if \(resetToggle\) elements\['auth-totp-enabled'\]\.focus\(\{ preventScroll: true \}\)/)
|
||
assert.match(script, /function discardTotpChangeOnPageLeave\(\)[\s\S]*keepalive: true[\s\S]*window\.addEventListener\('pagehide', discardTotpChangeOnPageLeave\)/)
|
||
assert.match(script, /auth-account-save'\]\.disabled = totpUnverified \|\| !accountDraftChanged\(\)/)
|
||
assert.match(style, /\.auth-totp-control\[data-state="unverified"\][^}]+background: var\(--warning\)/)
|
||
assert.match(script, /if \(!accountDraftChanged\(draft\)\) return/)
|
||
assert.match(script, /authCurrentPasswordRequired: '请输入当前主密码。'/)
|
||
assert.match(script, /authCurrentPasswordIncorrect: '当前主密码不正确。'/)
|
||
assert.match(script, /authManagementPasswordRequired: '请输入新的管理中心密码。'/)
|
||
assert.match(script, /renderPasswordConfirmation\('auth-password', 'auth-password-confirm'/)
|
||
assert.match(script, /renderPasswordConfirmation\('auth-additional-password', 'auth-additional-password-confirm'/)
|
||
assert.match(script, /'TOTP_DISABLE_CONFIRMATION_INVALID'/)
|
||
assert.match(script, /error\.code === 'FRESH_AUTH_FAILED'/)
|
||
assert.match(script, /authSavedAllSessionsRevoked/)
|
||
assert.match(script, /authSavedManagementSessionsRevoked/)
|
||
assert.match(script, /window\.location\.replace\(returnPath\)/)
|
||
assert.match(script, /window\.location\.assign\(new URL\(['"]\/['"], result\.loginOrigin\)\)/)
|
||
assert.doesNotMatch(script, /window\.location\.(?:assign|replace)\(new URL\('\/auth\/management'/)
|
||
assert.match(script, /const continuationOrigin = typeof result\.targetOrigin === 'string'/)
|
||
assert.match(script, /isolatedEntry\?\.managementLocalOrigin/)
|
||
assert.match(script, /function renderAdditionalPasswordFields\(\)[\s\S]*auth-additional-fields'/)
|
||
assert.match(script, /authenticationSettings\?\.account\?\.managementAdditionalCredential\?\.enabled === true[\s\S]*session\.managementActive === true/)
|
||
assert.match(script, /auth-additional-enabled'\]\.addEventListener\('change'[\s\S]*renderAdditionalPasswordFields/)
|
||
assert.match(script, /authMainPasswordTitle: '管理员账户'/)
|
||
assert.match(script, /authMainPasswordTitle: 'Administrator account'/)
|
||
assert.match(script, /authCurrentPasswordPlaceholder: '请输入当前主密码'/)
|
||
assert.match(script, /authCurrentPasswordPlaceholder: 'Enter the current main password'/)
|
||
assert.match(script, /authAdditionalTitle: '管理中心密码'/)
|
||
assert.match(script, /authAdditionalTitle: 'Management console password'/)
|
||
assert.match(script, /authNewPassword: '新密码'/)
|
||
assert.match(script, /authConfirmPassword: '确认密码'/)
|
||
assert.match(script, /authAdditionalPassword: '新密码'/)
|
||
assert.match(script, /authConfirmAdditionalPassword: '确认密码'/)
|
||
assert.match(script, /async function saveAccountSettings\(\)[\s\S]*auth-account-save'[\s\S]*api\('auth-settings'/)
|
||
assert.match(script, /async function saveManagementOrigin\(\)[\s\S]*auth-origin-save'[\s\S]*changeManagementOrigin/)
|
||
assert.match(script, /management-origin\/transitions\/failure/)
|
||
assert.match(script, /stage: 'browser-probe'/)
|
||
assert.match(script, /mode: access\.mode/)
|
||
assert.match(script, /auth-origin-settings'\]\.hidden = !isolated/)
|
||
assert.match(script, /auth-public-origin-field'\]\.hidden = selected !== 'isolated-public'/)
|
||
assert.match(script, /auth-local-port-field'\]\.hidden = !local/)
|
||
assert.match(script, /authLocalPort: '宿主机端口'/)
|
||
assert.match(script, /const accessInput = elements\['auth-mode'\]\.value === 'isolated-local'[\s\S]*elements\['auth-local-port'\][\s\S]*elements\['auth-origin'\]/)
|
||
assert.match(script, /!accessInput\.reportValidity\(\)/)
|
||
assert.match(script, /changeManagementOrigin\(nextAccess\)/)
|
||
assert.doesNotMatch(html, /auth-origin-current-password/)
|
||
assert.doesNotMatch(script, /saveAuthenticationSettings/)
|
||
assert.match(script, /elements\[confirmationId\]\.addEventListener\('input'[\s\S]*renderPasswordConfirmation/)
|
||
assert.match(script, /auth-username'\]\.addEventListener\('input'/)
|
||
assert.match(html, /id="auth-public-origin-field"[\s\S]*id="auth-origin"[\s\S]*id="auth-local-port-field" hidden[\s\S]*id="auth-local-port"[\s\S]*id="auth-origin-detect"/)
|
||
assert.match(html, /id="auth-isolation-dialog"[\s\S]*class="auth-comparison-table"/)
|
||
assert.match(html, /id="auth-isolation-confirm-dialog"[\s\S]*data-i18n="authIsolationConfirm"/)
|
||
assert.match(script, /function detectedManagementOrigin\(\)[\s\S]*value\.port = '3081'/)
|
||
assert.match(script, /option\.disabled = rootEnabled && accessMode\(option\.value\) !== currentMode/)
|
||
assert.doesNotMatch(html, /authComparisonAgent|Agent process isolation|Agent 进程隔离/)
|
||
assert.match(script, /modeChanged && nextAccess\.mode === 'isolated' && !await confirmIsolationEnable\(\)/)
|
||
assert.match(script, /function clearProxySecrets\(\)[\s\S]*elements\['proxy-password'\]\.value = ''/)
|
||
assert.doesNotMatch(script, /function sharedDshProxyEnabled\(\)/)
|
||
assert.doesNotMatch(script, /data-provider-follow|followDsh/)
|
||
assert.match(script, /function localizedProxyTestDetail\(stage, fallback\)/)
|
||
assert.match(script, /detail\.textContent = localizedProxyTestDetail\(stage, status\)/)
|
||
assert.match(script, /proxyStageDetailAddress: '已解析 \{count\} 个代理地址记录。'/)
|
||
assert.match(script, /proxyStageDetailAddress: 'Resolved \{count\} proxy address record\(s\)\.'/)
|
||
assert.match(style, /\.proxy-provider-route \{[^}]*background: var\(--surface-raised\)/)
|
||
assert.match(style, /proxy-test-stage\[data-state="running"\][^{]*\{[^}]*animation: spin/)
|
||
assert.match(style, /progress-stage-marker\.active::before[^{]*\{[^}]*animation: spin/)
|
||
assert.match(script, /function saveProxyConfiguration\(\)[\s\S]*proxyCandidate\(\)/)
|
||
assert.doesNotMatch(script, /function saveProxyRules\(/)
|
||
assert.match(script, /function saveProxyImmediate\(mutate\)[\s\S]*rules: 'saved'/)
|
||
assert.match(script, /function proxyCandidate\([\s\S]*enabled: configuration\.enabled === true/)
|
||
assert.match(script, /saveProxyImmediate\(configuration => \{ configuration\.enabled = event\.target\.checked \}\)/)
|
||
assert.match(script, /const componentUnavailable = configuration\.componentReady === false/)
|
||
assert.match(script, /proxy-enabled'\]\.disabled = componentUnavailable/)
|
||
assert.match(script, /proxy-protocol', 'proxy-host', 'proxy-port', 'proxy-username', 'proxy-password'/)
|
||
assert.match(script, /proxy-clear-password', 'proxy-advanced-toggle', 'proxy-direct-rules'/)
|
||
assert.match(script, /proxy-system-rules', 'proxy-remote-dns', 'proxy-provider-search', 'proxy-scope-help'/)
|
||
assert.match(script, /for \(const input of document\.querySelectorAll\('\[data-proxy-scope\]'\)\)[\s\S]*input\.disabled = componentUnavailable/)
|
||
assert.match(script, /proxy-all-proxy'\]\.disabled = componentUnavailable/)
|
||
assert.match(script, /proxy-test'\]\.disabled = componentUnavailable/)
|
||
assert.match(script, /proxy-save'\]\.disabled = componentUnavailable/)
|
||
assert.match(script, /proxy-password'\]\.disabled = proxyConfiguration\?\.componentReady === false/)
|
||
assert.match(script, /draft\.clearPassword === 'true'[\s\S]*proxyConfiguration\?\.componentReady === false/)
|
||
assert.match(script, /const componentUnavailable = proxyConfiguration\?\.componentReady === false[\s\S]*proxy-test'\]\.disabled = running \|\| componentUnavailable/)
|
||
assert.match(script, /proxy-component-alert'\]\.hidden = !componentUnavailable/)
|
||
assert.match(script, /proxy-component-alert'[\s\S]*proxy-component-dialog'\]\.showModal/)
|
||
assert.doesNotMatch(script, /proxyReadyShort|proxyUnavailableShort/)
|
||
assert.match(script, /function renderProxySaveState\(\{ saved = false \} = \{\}\)[\s\S]*proxyUnsaved[\s\S]*3000/)
|
||
assert.match(script, /const displayName =[\s\S]*return query === '' \|\| displayName\.toLocaleLowerCase\(\)\.includes\(query\)/)
|
||
assert.doesNotMatch(script, /\[provider\.displayName, provider\.id, provider\.type\]/)
|
||
assert.doesNotMatch(script, /(?:localStorage|sessionStorage)\.setItem\([^\n]*proxy-password/)
|
||
assert.match(html, /id="proxy-transport-warning"[^>]*data-i18n="proxyTransportWarning"/)
|
||
assert.match(html, /id="proxy-scope-dialog"[\s\S]*id="proxy-scope-catalog"/)
|
||
assert.match(script, /const override = storageValue\(LANGUAGE_KEY\)[\s\S]*navigator\.language[\s\S]*=== 'zh' \? 'zh' : 'en'/)
|
||
assert.doesNotMatch(script, /name === 'dsh_locale'/)
|
||
assert.match(script, /switchLanguage: '语言'/)
|
||
assert.match(script, /switchLanguage: 'Language'/)
|
||
assert.match(script, /elements\['language-switch'\]\.value = locale/)
|
||
assert.match(script, /elements\['language-switch'\]\.addEventListener\('change',[\s\S]*writeStorage\(LANGUAGE_KEY, event\.target\.value\)[\s\S]*window\.location\.reload\(\)/)
|
||
assert.match(script, /THEME_ORDER = Object\.freeze\(\['system', 'light', 'dark'\]\)/)
|
||
assert.match(script, /elements\['theme-switch'\]\.addEventListener\('click',[\s\S]*writeStorage\(THEME_KEY,[\s\S]*applyTheme\(themePreference\)[\s\S]*renderThemeControl\(\)/)
|
||
assert.match(script, /document\.documentElement\.dataset\.theme = preference[\s\S]*delete document\.documentElement\.dataset\.theme/)
|
||
assert.match(script, /checkUpdates\('page-open'\)/)
|
||
assert.match(script, /if \(statusLoad !== undefined\) return statusLoad/)
|
||
assert.match(script, /statusLoadRevision \+= 1/)
|
||
assert.match(script, /while \(loadedRevision !== statusLoadRevision\)/)
|
||
const statusLoader = script.slice(script.indexOf('function loadStatus()'), script.indexOf('async function discardSystemPluginDraft()'))
|
||
assert.match(statusLoader, /next = await api\('status'\)[\s\S]*setConnection\('online'\)/)
|
||
assert.doesNotMatch(statusLoader, /loadInventory|loadInventories/)
|
||
assert.match(script, /if \(inventoryLoads\[key\] !== undefined\) return inventoryLoads\[key\]/)
|
||
assert.match(script, /inventoryLoadRevisions\[key\] \+= 1[\s\S]*while \(loadedRevision !== inventoryLoadRevisions\[key\]\)/)
|
||
const inventoryLoader = script.slice(script.indexOf('const INVENTORY_LOADERS'), script.indexOf('function loadStatus()'))
|
||
for (const [key, route] of [['plugins', 'bundled-plugins'], ['systemSkills', 'system-skills'], ['userSkills', 'user-skills'], ['userPlugins', 'user-plugins']]) {
|
||
assert.match(inventoryLoader, new RegExp(`${key}: Object\\.freeze\\(\\{ path: '${route}'`))
|
||
}
|
||
assert.match(inventoryLoader, /loader\.apply\(await api\(loader\.path\)\)[\s\S]*inventoriesLoaded\[key\] = true[\s\S]*render\(status\)/)
|
||
assert.doesNotMatch(inventoryLoader, /Promise\.all\(\[[\s\S]*bundled-plugins[\s\S]*system-skills/)
|
||
assert.match(script, /function renderUserSkills\(busy\)[\s\S]*userSkillInventory\.skills/)
|
||
assert.match(script, /function renderUserSkills\(busy\)[\s\S]*row\.className = 'user-plugin-row'/)
|
||
assert.match(script, /expandedUserSkillDescriptions\.has\(skill\.entryId\)[\s\S]*description\.className = `user-plugin-description/)
|
||
assert.match(script, /description\.scrollWidth > description\.clientWidth[\s\S]*description\.classList\.add\('expandable'\)/)
|
||
assert.match(script, /heading\.append\(userPluginBadge\([\s\S]*identity\.append\(heading, description, metadata\)/)
|
||
assert.match(script, /requestConfirmation\(\{[\s\S]*deleteUserSkillTitle[\s\S]*deleteUserSkillDetail/)
|
||
assert.match(script, /runSkillTask\('user-skills\/action', \{[\s\S]*entryId: skill\.entryId, revision: userSkillInventory\.revision, action/)
|
||
assert.match(script, /function waitForManagementTask\(taskId, operationKey\)[\s\S]*operation\?\.taskId === taskId[\s\S]*operation\.status !== 'running'/)
|
||
assert.match(script, /function runSkillTask\(path, body, operationKey\)[\s\S]*waitForManagementTask\(task\.taskId, operationKey\)[\s\S]*refreshInventory\(operationKey === 'systemSkillOperation' \? 'systemSkills' : 'userSkills'\)/)
|
||
assert.match(script, /system-skills\/action'[\s\S]*systemSkillOperation/)
|
||
assert.match(script, /user-skills\/action'[\s\S]*userSkillOperation/)
|
||
assert.match(script, /inventoryKeyForTab\(tab[\s\S]*'user-skills': 'userSkills'/)
|
||
assert.match(script, /userSkillsTab: '用户技能'/)
|
||
assert.match(script, /userSkillsTab: 'User skills'/)
|
||
assert.match(script, /const inventoryKey = inventoryKeyForTab\(tab\)[\s\S]*void loadInventory\(inventoryKey\)/)
|
||
assert.match(script, /if \(inventoriesLoaded\.plugins\) renderBundledPlugins/)
|
||
assert.match(script, /if \(inventoriesLoaded\.userSkills\) renderUserSkills/)
|
||
assert.match(script, /LIST_PAGE_SIZES = Object\.freeze\(\[5, 10, 20, 50\]\)/)
|
||
assert.match(script, /LIST_PAGE_SIZE_KEY_PREFIX = 'dsh-platform:console-page-size:'/)
|
||
assert.match(script, /function paginated\(key, values\)[\s\S]*values\.slice\(start, start \+ pageSize\)/)
|
||
assert.match(script, /elements\[`\$\{prefix\}-pagination`\]\.hidden = false/)
|
||
assert.match(script, /writeStorage\(`\$\{LIST_PAGE_SIZE_KEY_PREFIX\}\$\{key\}`/)
|
||
assert.match(script, /const userPluginDraft = new Map\(\)[\s\S]*for \(const plugin of paginated\('userPlugins', filtered\)\)/)
|
||
assert.match(script, /function filteredResources\(key, values\)[\s\S]*listQueries\[key\]/)
|
||
assert.match(script, /function resourceSearchValues\(key, value\) \{[\s\S]*if \(key === 'plugins' \|\| key === 'systemSkills'\) return \[value\.id\][\s\S]*if \(key === 'userSkills'\) return \[value\.name \?\? value\.entryName\][\s\S]*return \[value\.name\]/)
|
||
const resourceSearch = script.slice(script.indexOf('function resourceSearchValues('), script.indexOf('function filteredResources('))
|
||
assert.doesNotMatch(resourceSearch, /value\.(?:description|version|spec|source)/)
|
||
assert.match(script, /function expandableResourceDescription[\s\S]*scrollWidth > description\.clientWidth/)
|
||
assert.match(script, /function captureScrollablePositions\(element, includeElement = false\)[\s\S]*current\.scrollTop/)
|
||
assert.match(script, /function restoreScrollablePositions\(positions\)[\s\S]*current\.scrollTop = top[\s\S]*requestAnimationFrame/)
|
||
for (const [renderer, list] of [
|
||
['renderBundledPlugins', 'bundled-plugins'], ['renderSystemSkills', 'system-skills'],
|
||
['renderUserSkills', 'user-skills'], ['renderUserPlugins', 'user-plugin-list'],
|
||
]) {
|
||
const start = script.indexOf(`function ${renderer}(`)
|
||
const end = script.indexOf('\nfunction ', start + 1)
|
||
const source = script.slice(start, end)
|
||
assert.match(source, new RegExp(`captureScrollablePositions\\(elements\\['${list}'\\], true\\)`))
|
||
assert.match(source, /restoreScrollablePositions\(scrollPositions\)/)
|
||
}
|
||
assert.match(script, /function render\(next\) \{[\s\S]*\.resource-panel:not\(\[hidden\]\)[\s\S]*captureScrollablePositions\(activeResourcePanel, true\)[\s\S]*restoreScrollablePositions\(resourcePanelScrollPositions\)/)
|
||
assert.match(script, /function toggleExpandedElement[\s\S]*preserveScrollableAncestors\(element, \(\) =>/)
|
||
assert.match(script, /identity\.append\(\s*heading,\s*expandableResourceDescription\(pluginDescription\(plugin\)/)
|
||
assert.match(script, /identity\.append\(\s*heading,\s*expandableResourceDescription\(skill\.description/)
|
||
assert.match(style, /\.plugin-identity > \.resource-description \{[^}]*display: block;[^}]*margin-top: 2px;/)
|
||
assert.match(style, /\.user-plugin-main dl \{[^}]*grid-template-columns: repeat\(3, minmax\(0, 1fr\)\);/)
|
||
assert.match(style, /\.user-plugin-main > \.user-plugin-description \{[^}]*display: block;[^}]*width: 100%;[^}]*margin-top: 2px;/)
|
||
assert.match(script, /function expandableUserMetadata\(metadata, identity, expanded\)[\s\S]*value\.scrollWidth > value\.clientWidth/)
|
||
assert.match(script, /function toggleExpandedElement\(element, identity, expanded\)[\s\S]*classList\.toggle\('expanded', isExpanded\)/)
|
||
assert.doesNotMatch(script, /expandedUserSkillDescriptions[\s\S]{0,300}renderUserSkills\(runtimeBusy\(\)\)/)
|
||
assert.doesNotMatch(script, /expandedUserPluginDescriptions[\s\S]{0,300}renderUserPlugins\(runtimeBusy\(\)\)/)
|
||
assert.match(script, /expandedUserSkillMetadata[\s\S]*expandableUserMetadata\(metadata, skill\.entryId/)
|
||
assert.match(script, /expandedUserPluginMetadata[\s\S]*expandableUserMetadata\(metadata, plugin\.name/)
|
||
assert.match(style, /\.user-plugin-main dt, \.user-plugin-main dd \{[^}]*overflow: hidden;[^}]*text-overflow: ellipsis;[^}]*white-space: nowrap;/)
|
||
assert.match(style, /\.user-plugin-metadata\.expanded dd \{[^}]*overflow-wrap: anywhere;[^}]*white-space: normal;/)
|
||
assert.equal((style.match(/\.user-plugin-main dl \{/g) ?? []).length, 1)
|
||
for (const prefix of ['plugins', 'system-skills', 'user-skills', 'user-plugins']) {
|
||
assert.match(html, new RegExp(`id="${prefix}-search"`))
|
||
assert.match(html, new RegExp(`id="${prefix}-page-size"`))
|
||
assert.match(html, new RegExp(`id="${prefix}-page-previous"`))
|
||
assert.match(html, new RegExp(`id="${prefix}-page-next"`))
|
||
assert.match(html, new RegExp(`id="${prefix}-page-current"`))
|
||
assert.match(html, new RegExp(`id="${prefix}-page-jump"`))
|
||
}
|
||
for (const [emptyId, paginationId] of [
|
||
['empty-plugins', 'plugins-pagination'],
|
||
['empty-user-plugins', 'user-plugins-pagination'],
|
||
['empty-skills', 'system-skills-pagination'],
|
||
['empty-user-skills', 'user-skills-pagination'],
|
||
]) assert.equal(html.indexOf(`id="${emptyId}"`) < html.indexOf(`id="${paginationId}"`), true)
|
||
assert.match(html, /class="management-navigation"/)
|
||
assert.doesNotMatch(html, /class="page-heading"/)
|
||
assert.doesNotMatch(script, /intro: 'DSH Docker/)
|
||
assert.equal((html.match(/class="tab-panel resource-panel"/g) ?? []).length, 4)
|
||
assert.match(style, /html \{[^}]*height: 100%;[^}]*overflow: hidden;/)
|
||
assert.match(style, /body \{[^}]*height: 100dvh;[^}]*overflow: hidden;/)
|
||
assert.match(style, /main \{[^}]*height: calc\(100dvh - 64px\);[^}]*overflow: hidden;/)
|
||
assert.match(style, /body \{ position: fixed; inset: 0; width: 100%; height: 100dvh;[^}]*overflow: hidden; \}/)
|
||
assert.match(style, /\.management-navigation \{[^}]*width: 100%;[^}]*min-width: 0;[^}]*max-width: 100%;[^}]*flex: none;[^}]*background: var\(--bg\);/)
|
||
assert.doesNotMatch(style, /\.management-navigation \{[^}]*padding-top:/)
|
||
assert.doesNotMatch(style, /\.page-heading/)
|
||
assert.match(style, /\.tab-panel \{[^}]*min-height: 0;[^}]*flex: 1;[^}]*overflow-y: auto;[^}]*scrollbar-gutter: stable;/)
|
||
assert.match(style, /\.resource-panel \.plugin-list, \.resource-panel \.user-plugin-list \{[^}]*max-height: min\(52dvh, 520px\);[^}]*flex: 0 1 auto;[^}]*overflow-y: auto;/)
|
||
assert.match(style, /\.resource-panel \.plugin-list \{ min-height: 60px; \}/)
|
||
assert.match(style, /\.resource-panel \.user-plugin-list \{ min-height: 96px; \}/)
|
||
assert.match(style, /@media \(max-width: 640px\)[\s\S]*\.resource-panel \.plugin-list \{ min-height: 122px; \}[\s\S]*\.resource-panel \.user-plugin-list \{ min-height: 170px; \}/)
|
||
assert.match(style, /\.resource-panel \.list-pagination \{[^}]*position: static;/)
|
||
assert.doesNotMatch(style, /max-height: min\(calc\(56\.25vw - 27px\), 664px\)/)
|
||
assert.match(script, /commitListPageJump/)
|
||
assert.match(script, /Math\.min\(lastPage, Math\.max\(0, value - 1\)\)[\s\S]*input\.value = String\(listPages\[key\] \+ 1\)/)
|
||
assert.match(script, /listQueries\[key\] = event\.target\.value[\s\S]*listPages\[key\] = 0/)
|
||
assert.match(script, /connectEvents\(\)[\s\S]*void \(async \(\) => \{[\s\S]*const initial = await loadStatus\(\)/)
|
||
assert.doesNotMatch(script, /^await /m)
|
||
assert.match(script, /initial !== undefined && UPDATE_TERMINAL_STATES\.has/)
|
||
assert.match(script, /discardingPluginDraft[\s\S]*renderBundledPlugins\(plugins, pluginBusy\)/)
|
||
assert.match(script, /for \(const \[id, action\] of systemPluginDraft\) systemPluginApplyingDraft\.set\(id, action\)[\s\S]*waitForManagementTask/)
|
||
assert.match(script, /await discardSystemPluginDraft\(\)[\s\S]*checkUpdates\('page-open'\)/)
|
||
assert.doesNotMatch(script, /NOTICE_PREFIX|notificationCandidates|renderReminder|candidateIdentity/)
|
||
assert.doesNotMatch(html, /id="update-reminder"|id="reminder-later"|id="reminder-dismiss"/)
|
||
assert.doesNotMatch(style, /\.update-reminder/)
|
||
assert.match(script, /updateNotifications: '更新提醒'/)
|
||
assert.match(script, /updateNotifications: 'Update notifications'/)
|
||
assert.match(script, /updateNotificationsDetail: '自动检查发现新版本时，在 DSH 页面弹窗提醒更新。'/)
|
||
assert.match(script, /LOG_CLEAR_CUTOFF_KEY = 'dsh-platform:log-clear-cutoff'/)
|
||
assert.match(script, /sessionStorage\.setItem\(LOG_CLEAR_CUTOFF_KEY, logClearCutoff\)/)
|
||
assert.match(script, /timestamp <= Date\.parse\(logClearCutoff\)/)
|
||
assert.match(script, /DEFAULT_LOG_DISPLAY_LIMIT = 500/)
|
||
assert.match(script, /limitProcessedLogEntries\(logEntries, logDisplayLimit\)/)
|
||
assert.match(script, /expandedLogIdentities/)
|
||
assert.match(script, /details\.textContent = JSON\.stringify\(entry, null, 2\)/)
|
||
assert.match(script, /article\.setAttribute\('aria-expanded'/)
|
||
assert.match(script, /chevron\.className = 'log-chevron'/)
|
||
assert.match(script, /meta\.append\(levelLabel, sourceLabel, time\)/)
|
||
assert.match(script, /messageRow\.append\(message, chevron\)/)
|
||
assert.match(script, /message\.textContent = display\(logMessageSummary\(entry\.message\)\)/)
|
||
assert.match(script, /total: logDisplayLimit/)
|
||
assert.match(script, /writeStorage\(LOG_DISPLAY_LIMIT_KEY, String\(value\)\)/)
|
||
assert.match(html, /id="log-limit"/)
|
||
assert.match(script, /tab === 'maintenance' && autoScroll[\s\S]*requestAnimationFrame[\s\S]*scrollTop = elements\['log-list'\]\.scrollHeight/)
|
||
const checkUpdates = script.slice(script.indexOf('async function checkUpdates('), script.indexOf('async function saveAutomaticCheck('))
|
||
assert.match(checkUpdates, /await api\('check'/)
|
||
assert.doesNotMatch(checkUpdates, /await act\(/)
|
||
assert.match(html, /id="plugin-restart-required"/)
|
||
assert.match(html, /id="system-plugin-draft-summary"/)
|
||
assert.match(html, /data-channel="stable" aria-pressed="true"/)
|
||
assert.match(html, /id="upstream-version" hidden/)
|
||
assert.match(html, /id="update"[^>]*disabled/)
|
||
assert.match(html, /id="cancel-system-plugin-changes"/)
|
||
assert.match(html, /id="apply-system-plugin-changes"/)
|
||
assert.match(html, /id="runtime-reset"[^>]*aria-controls="runtime-reset-confirmation"[^>]*aria-expanded="false"/)
|
||
assert.match(html, /id="runtime-reset-confirmation"[^>]*hidden/)
|
||
assert.match(script, /runtimeReset: '重置运行时'/)
|
||
assert.match(script, /runtimeReset: 'Reset runtime'/)
|
||
assert.match(script, /function setRuntimeResetExpanded\(expanded\)/)
|
||
assert.match(script, /await act\('runtime\/reset', \{ method: 'POST' \}\)/)
|
||
assert.match(script, /next\?\.runtimeReset\?\.status === 'resetting'/)
|
||
assert.equal(html.indexOf('id="plugin-restart-required"') < html.indexOf('id="bundled-plugins"'), true)
|
||
assert.match(script, /plugins\.some\(plugin => plugin\.pendingRestart\)/)
|
||
assert.match(pluginSource, /statusLoadRevision\.current \+= 1/)
|
||
assert.match(pluginSource, /if \(statusLoad\.current !== undefined\) return statusLoad\.current/)
|
||
assert.match(pluginSource, /while \(loadedRevision !== statusLoadRevision\.current\)/)
|
||
assert.match(pluginSource, /const API = '\/_dsh_platform\/plugin-api\/v1'/)
|
||
assert.equal(pluginSource.match(/href: managementConsoleHref/g)?.length, 2)
|
||
assert.doesNotMatch(pluginSource, /href: '\/_dsh_platform\/auth\/management\/start/)
|
||
assert.doesNotMatch(pluginSource, /platformAuthRequired|platformSignIn|authRequired/)
|
||
assert.match(script, /pluginChangesPending: '有待应用的修改'/)
|
||
assert.match(html, /id="update-progress" class="update-progress"/)
|
||
assert.match(html, /id="progress-stage-log" class="progress-stage-log" hidden/)
|
||
assert.match(html, /id="progress-dismiss"[\s\S]*data-i18n="dismissProgress"/)
|
||
assert.doesNotMatch(html, /id="progress-steps"|id="progress-metrics"|id="progress-detail"/)
|
||
assert.match(script, /function progressStageDefinitions\(update\)/)
|
||
assert.match(script, /function stageMetricLines\(value, stage, state\)/)
|
||
assert.match(script, /function stageItems\(stage, update, state\)/)
|
||
assert.match(script, /stageItemsCompleted: '已完成 \{completed\}\/\{total\} 项'/)
|
||
assert.match(script, /itemMarker\.textContent = ''/)
|
||
assert.match(script, /metricBytesCopied: '已复制 \{processed\} \/ \{total\}'/)
|
||
assert.match(script, /metricArtifacts: '已验证 \{processed\} \/ \{total\} 个 Artifact'/)
|
||
assert.match(script, /function probationRemainingSeconds\(update\)[\s\S]*probation:\(\\d\+\)/)
|
||
assert.match(script, /metricProbationRemaining: '剩余观察 \{seconds\} 秒'/)
|
||
assert.match(script, /taskId: String\(taskId\), operation: String\(update\.operation \?\? 'update'\), limit: '1000'/)
|
||
assert.match(script, /function progressLogStage\(phase, update = progressLogUpdate\)/)
|
||
assert.match(script, /function isRecoveryOperation\(operation\)[\s\S]*operation === 'return-stable'/)
|
||
assert.match(script, /returnStableProgress: '返回稳定通道'/)
|
||
assert.match(script, /'restoring-data': 3/)
|
||
assert.match(script, /const UPDATE_RECOVERY_STAGE_ITEMS = Object\.freeze\(\[[\s\S]*'itemSwitchPrevious'[\s\S]*'itemRestoreSnapshot'[\s\S]*'itemStartRuntime'[\s\S]*'itemCheckHealth'/)
|
||
assert.match(script, /phase === 'restoring-data'[\s\S]*'recovery:snapshot': 1[\s\S]*'recovery:health': 3/)
|
||
assert.match(script, /returnStableToTarget: '返回稳定通道·\{target\}'/)
|
||
assert.match(script, /progressLogStageExpansion\.set\(previousActiveStage, false\)/)
|
||
assert.match(script, /function transactionStageState\(index, currentIndex, status\)[\s\S]*status === 'success'[\s\S]*return 'completed'/)
|
||
assert.match(script, /progressLogStageExpansion\.set\(activeStage\.key, update\.status !== 'success'\)/)
|
||
assert.match(script, /elements\.progress\.dataset\.complete = String\(progress === 100\)/)
|
||
assert.match(script, /stageSummary\.addEventListener\('click',[\s\S]*progressLogStageTouched\.add\(group\.key\)/)
|
||
assert.match(script, /toggle\.addEventListener\('click',[\s\S]*const nextOpen = !stageDetails\.open[\s\S]*stageDetails\.open = nextOpen/)
|
||
assert.match(script, /stageDetails\.addEventListener\('toggle',[\s\S]*toggle\.textContent = t\(stageDetails\.open \? 'collapseStage' : 'expandStage'/)
|
||
assert.match(script, /progressLogStageExpansion\.set\(group\.key, nextOpen\)[\s\S]*toggle\.textContent = t\(nextOpen \? 'collapseStage' : 'expandStage'/)
|
||
assert.match(script, /if \(update\.status === 'success'\) \{\s*if \(previousStatus !== 'success'\) \{[\s\S]*progressLogStageExpansion\.set\(activeStage\.key, false\)/)
|
||
assert.doesNotMatch(script, /if \(update\.status === 'success'\) \{\s*if \(previousStatus !== 'success'\) progressLogStageTouched\.delete\(activeStage\.key\)\s*progressLogStageExpansion\.set\(activeStage\.key, false\)/)
|
||
assert.doesNotMatch(script, /stageDetails\.addEventListener\('toggle',[\s\S]{0,160}progressLogStageTouched\.add/)
|
||
assert.match(script, /function progressLogPhase\(update\) \{[\s\S]*update\?\.phase[\s\S]*update\?\.operation[\s\S]*update\?\.status/)
|
||
assert.match(script, /progressLogAutoScroll = event\.target\.checked/)
|
||
assert.match(script, /elements\['log-search'\]\.value = String\(progressLogUpdate\.taskId\)/)
|
||
assert.match(script, /const failedDismissed = update\.status === 'failed'[\s\S]*dismissedProgressTaskId/)
|
||
assert.match(script, /const result = progressVisible \|\| failedDismissed \? '' : update\.error/)
|
||
assert.match(script, /elements\['progress-dismiss'\]\.addEventListener\('click'/)
|
||
assert.match(style, /\.progress-log-group-list[\s\S]*max-height: 250px/)
|
||
assert.match(style, /\.progress\[data-complete='true'\] span \{ width: 100% !important; transition: none; \}/)
|
||
assert.match(style, /\.progress-log-group-list\.populated \{ height: clamp\(160px, 24dvh, 240px\);/)
|
||
assert.doesNotMatch(style, /\.progress-log-entry:last-child \{[^}]*border-bottom: 0;/)
|
||
assert.match(style, /\.progress-log-entry summary[\s\S]*grid-template-columns: auto minmax\(0, 1fr\) auto/)
|
||
assert.match(style, /\.progress-log-message \{[^}]*grid-column: 1 \/ 3;/)
|
||
assert.match(script, /chevron\.className = 'progress-log-chevron'/)
|
||
assert.match(style, /\.progress-log-entry\[open\] \.progress-log-chevron::before \{ transform: rotate\(180deg\); \}/)
|
||
assert.match(script, /rollbackDetailData: '正在校验并恢复更新前的数据快照。'/)
|
||
assert.match(style, /\.progress-stage-marker \{ --marker-size: 10px;/)
|
||
assert.match(style, /\.progress-stage-item-marker \{ --marker-size: 10px;/)
|
||
assert.doesNotMatch(script, /[✓⟳✗○]/u)
|
||
assert.match(script, /pluginChangesPending: 'Changes pending'/)
|
||
assert.match(script, /pendingSystemPluginChanges: '有 \{count\} 项修改待应用'/)
|
||
assert.match(script, /systemPluginApplyingItem: '\{action\} @dsh-docker\/\{id\}（\{current\}\/\{total\}）'/)
|
||
assert.match(script, /function systemPluginSummary\(\)[\s\S]*systemPluginProgress\?\.phase === 'restarting'[\s\S]*pendingSystemPluginChanges/)
|
||
assert.match(script, /function reconcileSystemPluginProgress\(next\)[\s\S]*lifecycle\?\.taskId !== systemPluginProgress\.taskId[\s\S]*\['running', 'failed', 'stopped'\]/)
|
||
assert.match(script, /systemPluginProgress = \{ phase: 'restarting', total: changes\.length, taskId: restart\.taskId \}/)
|
||
assert.match(script, /systemPluginProgress = \{ phase: 'applying', id, action, current: index \+ 1, total: changes\.length \}/)
|
||
assert.match(script, /userPluginRestartRequired: '需要重新启动 DSH'/)
|
||
assert.match(script, /userPluginRestartRequired: 'Restart DSH required'/)
|
||
assert.doesNotMatch(html, /id="user-plugin-restart-required"/)
|
||
assert.match(script, /const applyingAction = userPluginApplyingDraft\.get\(plugin\.name\)[\s\S]*plugin\.pendingRestart[\s\S]*pluginPendingRestart/)
|
||
assert.match(script, /const userPluginApplyingDraft = new Map\(\)/)
|
||
assert.match(script, /const applyingAction = userPluginApplyingDraft\.get\(plugin\.name\)[\s\S]*statusEnabling[\s\S]*statusDisabling[\s\S]*statusUninstalling/)
|
||
assert.match(script, /for \(const \[name, action\] of userPluginDraft\) userPluginApplyingDraft\.set\(name, action\)[\s\S]*await refreshInventory\('userPlugins'\)[\s\S]*userPluginApplyingDraft\.clear\(\)/)
|
||
assert.match(script, /plugin\.description\?\.\[locale\]/)
|
||
assert.match(script, /pluginPendingRestart: '待重启'/)
|
||
assert.match(script, /PLUGIN_DRAFT_KEY = 'dsh-platform:system-plugin-draft'/)
|
||
assert.match(script, /const systemPluginDraft = new Map\(\)/)
|
||
assert.match(script, /function setSystemPluginDraft\(plugin, action\)[\s\S]*systemPluginDraft\.set\(plugin\.id, action\)/)
|
||
assert.match(script, /const restartRequired = systemPluginDraft\.size > 0 \|\| values\.some\(plugin => plugin\.pendingRestart\)[\s\S]*const applyingAction = restartRequired[\s\S]*systemPluginApplyingDraft\.get\(plugin\.id\)/)
|
||
assert.match(script, /userPluginBadge\(t\(stateKey[\s\S]*applyingAction !== undefined \|\| action !== undefined \? 'pending' : plugin\.enabled \? 'enabled'/)
|
||
const systemPluginRenderer = script.slice(script.indexOf('function renderBundledPlugins('), script.indexOf('function renderSystemSkills('))
|
||
assert.doesNotMatch(systemPluginRenderer, /pluginPendingRestart/)
|
||
assert.match(systemPluginRenderer, /action !== undefined[\s\S]*pendingInstall[\s\S]*pendingUninstall[\s\S]*pendingEnable[\s\S]*pendingDisable/)
|
||
assert.match(script, /function pluginButton\([\s\S]*setSystemPluginDraft\(plugin, action\)/)
|
||
assert.match(script, /async function applySystemPluginDraft\(\)[\s\S]*for \(const \[id, action\] of systemPluginDraft\)[\s\S]*waitForManagementTask\(task\.taskId, 'systemPluginOperation'\)[\s\S]*api\('restart-dsh'/)
|
||
assert.match(script, /operationKey === 'systemPluginOperation'[\s\S]*api\(`bundled-plugins\/task\/\$\{taskId\}`\)/)
|
||
assert.match(script, /async function cancelSystemPluginDraft\(\)[\s\S]*systemPluginDraft\.clear\(\)[\s\S]*bundled-plugins\/discard/)
|
||
assert.match(script, /function hasTaskId\(operation\)[\s\S]*typeof operation\?\.taskId === 'string'[\s\S]*operation\.taskId\.length > 0/)
|
||
assert.match(script, /restart\.state === 'running' && hasTaskId\(restart\)[\s\S]*sessionStorage\.removeItem\(PLUGIN_DRAFT_KEY\)/)
|
||
assert.doesNotMatch(script, /if \(hadDraft\) sessionStorage\.removeItem\(PLUGIN_DRAFT_KEY\)/)
|
||
assert.match(script, /\(acting && !checking\)/)
|
||
assert.match(script, /const checkingProgress = update\.operation === 'check'[\s\S]*checkingProgress[\s\S]*t\('statusChecking'\)[\s\S]*updateToTarget/)
|
||
assert.doesNotMatch(script, /可离线恢复|Offline recovery|recovery-badge/)
|
||
assert.doesNotMatch(script, /插件设置并重启 DSH|settings and restarting DSH/)
|
||
assert.doesNotMatch(script, /shell\.overlay|settings\.section|dsh-platform:update-notice-owner/)
|
||
assert.doesNotMatch(script, /^import .*vendor\/xterm\.mjs/m)
|
||
assert.match(script, /import\('\.\/vendor\/xterm\.mjs'\)/)
|
||
assert.match(script, /import\('\.\/vendor\/addon-fit\.mjs'\)/)
|
||
assert.match(script, /terminalLoading: '正在加载终端组件'/)
|
||
assert.match(script, /terminalLoading: 'Loading terminal components'/)
|
||
assert.match(script, /cursorStyle: 'block'/)
|
||
assert.match(script, /cursorInactiveStyle: 'outline'/)
|
||
assert.match(style, /#terminal-screen \.xterm-viewport \{ position: static;/)
|
||
assert.match(script, /const badge = applyingAction[\s\S]*plugin\.pendingRestart[\s\S]*plugin\.reservedNameConflict[\s\S]*plugin\.damaged[\s\S]*plugin\.enabled/)
|
||
assert.match(script, /const applying = operation\.status === 'running'[\s\S]*hidden = count === 0 && !restartRequired && !applying/)
|
||
assert.doesNotMatch(style, /user-plugin-badges/)
|
||
assert.match(script, /user-plugin-draft-actions'\]\.hidden = count === 0 && !restartRequired/)
|
||
assert.match(script, /userPluginDraft\.size === 0[\s\S]*userPluginInventory\.restartRequired === true[\s\S]*act\('restart-dsh', \{ method: 'POST' \}\)/)
|
||
assert.match(script, /terminalEmulator\?\.focus\(\)/)
|
||
assert.match(serverSource, /style-src 'self' 'unsafe-inline'/)
|
||
assert.match(serverSource, /script-src 'self'; style-src/)
|
||
assert.match(html, /id="terminal-loader"[^>]*hidden/)
|
||
assert.doesNotMatch(html, /href="\.\/vendor\/xterm\.css"/)
|
||
assert.match(script, /stylesheet\.href = '\.\/vendor\/xterm\.css'/)
|
||
assert.match(script, /if \(tab === 'maintenance'\) \{\s*connectLogs\(\)/)
|
||
assert.match(script, /function connectLogs\(\{ force = false \} = \{\}\)/)
|
||
assert.match(script, /addEventListener\('heartbeat'/)
|
||
assert.match(script, /Date\.now\(\) - logLastActivity > 35_000/)
|
||
assert.match(html, /id="refresh-logs"[^>]*data-i18n="refreshLogs"/)
|
||
assert.match(html, /id="export-logs"[^>]*data-i18n="exportLogs"/)
|
||
assert.match(script, /function refreshLogs\(\)[\s\S]*api\(`logs\?limit=/)
|
||
assert.match(script, /function filteredRawLogs\(\)/)
|
||
assert.match(script, /application\/x-ndjson;charset=utf-8/)
|
||
assert.match(script, /dsh-platform-logs-.*\.jsonl/)
|
||
assert.match(script, /logIdentities\.has\(identity\)/)
|
||
assert.match(script, /function scheduleLogRender\(\)/)
|
||
assert.match(script, /maintenance: 'DSH 生命周期'/)
|
||
assert.match(script, /maintenance: 'DSH lifecycle'/)
|
||
assert.match(html, /id="start-dsh"[\s\S]*id="stop-dsh"[\s\S]*id="restart-dsh"/)
|
||
assert.match(html, /id="stop-dialog"/)
|
||
assert.match(script, /act\('start-dsh', \{ method: 'POST' \}\)/)
|
||
assert.match(script, /act\('stop-dsh', \{ method: 'POST' \}\)/)
|
||
assert.match(script, /TERMINAL_SESSION_KEY = 'dsh-platform:terminal-session'/)
|
||
assert.match(script, /sessionStorage\.setItem\(TERMINAL_SESSION_KEY, value\)/)
|
||
assert.match(script, /new WebSocket\(terminalWebSocketUrl\(sessionId\)\)/)
|
||
assert.match(script, /terminalEmulator\.reset\(\)[\s\S]*new WebSocket/)
|
||
assert.match(script, /terminalReconnectDeadline \?\?= Date\.now\(\) \+ 30_000/)
|
||
assert.match(script, /terminalFit\.fit\(\)/)
|
||
assert.match(script, /filesTab: '文件管理'/)
|
||
assert.match(script, /filesTab: 'Files'/)
|
||
assert.match(script, /if \(tab === 'files' && !filesLoaded\) void initializeFiles/)
|
||
assert.match(script, /api\('files\/config'\)/)
|
||
assert.match(script, /elements\['file-shortcuts'\]\.replaceChildren/)
|
||
assert.doesNotMatch(html, /data-file-location="\/workspace"/)
|
||
assert.doesNotMatch(script, /scrollIntoView\(\{ block: 'nearest', inline: 'nearest' \}\)/)
|
||
assert.match(script, /new XMLHttpRequest\(\)/)
|
||
assert.match(script, /fileClipboard = null/)
|
||
assert.match(script, /fileOwner: '用户:用户组'/)
|
||
assert.match(script, /fileOwner: 'User:group'/)
|
||
assert.match(script, /operation: 'size'/)
|
||
assert.match(script, /calculateDirectorySize/)
|
||
assert.match(script, /operation: 'attributes'/)
|
||
assert.match(script, /attributes: \{[\s\S]*user, group, mode,[\s\S]*recursive:/)
|
||
assert.match(script, /FILE_ATTRIBUTES_UNSUPPORTED[^\n]*attributesUnsupported/)
|
||
assert.match(script, /syncPermissionChecks/)
|
||
assert.match(script, /syncModeFromPermissions/)
|
||
assert.match(script, /elements\['file-attributes-group'\]\.value = event\.target\.value/)
|
||
assert.match(html, /data-i18n="fileOwner"/)
|
||
assert.match(html, /class="file-sort-arrows"/)
|
||
assert.match(script, /function renderFileSort\(\)/)
|
||
assert.match(script, /button\.closest\('th'\)\.setAttribute\('aria-sort'/)
|
||
assert.match(style, /\.file-searchbar label \{[^}]*display: inline-flex;[^}]*align-items: center;/)
|
||
assert.match(style, /\.resource-heading-detail \{[^}]*display: flex;[^}]*align-items: center;/)
|
||
assert.match(style, /\.resource-search \{[^}]*width: min\(320px, 45%\);[^}]*margin: 0 0 0 auto;/)
|
||
assert.match(style, /@media \(max-width: 640px\)[\s\S]*\.resource-heading-detail \{[^}]*flex-direction: column;[^}]*\}[\s\S]*\.resource-search \{[^}]*width: 100%;[^}]*margin-left: 0;/)
|
||
assert.match(style, /\.file-table \{[^}]*min-width: 600px;/)
|
||
assert.match(style, /button\[data-sort-order='asc'\]/)
|
||
assert.match(script, /const visibleOperationTasks = new Set\(\)/)
|
||
assert.match(script, /function operationResultVisible\(operation, activeStatus\)/)
|
||
assert.match(script, /elements\['restart-state'\]\.hidden = !restartVisible/)
|
||
assert.match(script, /elements\['runtime-reset-progress'\]\.hidden = !resetActive/)
|
||
assert.match(script, /RUNTIME_RESET_PHASES\[next\.operation\]/)
|
||
assert.match(script, /runtimeResetProgress = resetActive \? Math\.max\(runtimeResetProgress, resetPhase\.progress\) : 0/)
|
||
assert.match(html, /id="runtime-reset-progress-track"[^>]*role="progressbar"/)
|
||
assert.match(script, /elements\['runtime-reset'\]\.disabled = busy \|\| next\.current === null/)
|
||
assert.match(html, /id="runtime-reset"[^>]*disabled/)
|
||
assert.match(script, /elements\['plugin-operation'\]\.hidden = !pluginOperationVisible \|\| pluginOperation\.status !== 'failed'/)
|
||
assert.match(script, /pendingInstall: '待安装'[\s\S]*statusInstalling: '安装中'[\s\S]*resourceEnabled: '已启用'/)
|
||
assert.match(script, /heading\.append\([\s\S]*userPluginBadge\(t\(stateKey[\s\S]*name,[\s\S]*expandableResourceDescription/)
|
||
const bundledPluginRenderer = script.slice(script.indexOf('function renderBundledPlugins('), script.indexOf('function renderSystemSkills('))
|
||
const systemSkillRenderer = script.slice(script.indexOf('function renderSystemSkills('), script.indexOf('function userSkillSource('))
|
||
assert.doesNotMatch(bundledPluginRenderer, /label\.textContent = projected\.enabled/)
|
||
assert.doesNotMatch(systemSkillRenderer, /label\.textContent = skill\.enabled/)
|
||
assert.match(html, /id="file-attributes"[^>]*aria-controls="file-attributes-panel"/)
|
||
assert.match(html, /id="file-attributes-panel"[^>]*hidden/)
|
||
assert.match(html, /data-permission-bit="256"/)
|
||
assert.match(html, /id="file-attributes-recursive"/)
|
||
assert.match(style, /\.file-permission-grid \{[\s\S]*grid-template-columns:/)
|
||
assert.doesNotMatch(script, /window\.(?:alert|confirm|prompt)/)
|
||
assert.match(html, /id="text-input-dialog"/)
|
||
assert.match(html, /id="confirmation-dialog"/)
|
||
assert.match(script, /function requestTextInput\(/)
|
||
assert.match(script, /function requestConfirmation\(/)
|
||
assert.match(html, /id="file-editor-lines"/)
|
||
assert.match(html, /id="file-new"[^>]*aria-controls="file-create-panel"[^>]*aria-expanded="false"/)
|
||
assert.match(html, /id="file-create-panel"[^>]*hidden/)
|
||
assert.match(html, /data-file-create-kind="touch"[^>]*aria-pressed="true"/)
|
||
assert.match(html, /data-file-create-kind="mkdir"[^>]*aria-pressed="false"/)
|
||
assert.match(script, /function fileNameIsValid\(value\)[\s\S]*new TextEncoder\(\)\.encode\(value\)\.byteLength <= 255/)
|
||
assert.match(script, /const destination = filePath === '\/' \? `\/\$\{name\}` : `\$\{filePath\}\/\$\{name\}`/)
|
||
assert.doesNotMatch(script, /file-new[\s\S]{0,200}window\.prompt/)
|
||
assert.doesNotMatch(script, /chooseConflict|window\.prompt\(t\('chooseConflict'/)
|
||
assert.match(html, /id="file-conflict-dialog"/)
|
||
assert.match(html, /name="file-conflict-choice" value="overwrite"/)
|
||
assert.match(html, /name="file-conflict-choice" value="rename"/)
|
||
assert.match(html, /name="file-conflict-choice" value="skip"/)
|
||
assert.match(html, /id="file-conflict-all"/)
|
||
assert.match(html, /id="file-conflict-confirm"[^>]*data-i18n="confirmChoice"/)
|
||
assert.match(script, /error\.code === 'FILE_EXISTS'/)
|
||
assert.match(script, /if \(decision\.applyAll\) conflictForAll = decision\.choice/)
|
||
assert.match(style, /\.file-conflict-options \{[^}]*display: grid/)
|
||
assert.match(style, /\.file-conflict-dialog \.confirm\[hidden\] \{ display: none; \}/)
|
||
assert.match(maintenanceSource, /files\.\$\{operation\}\.rejected/)
|
||
assert.match(maintenanceSource, /result\.path \?\? result\.destination \?\? result\.sources/)
|
||
assert.match(style, /\.file-create-panel \{[^}]*grid-template-columns:/)
|
||
assert.match(html, /id="file-back"[^>]*disabled/)
|
||
assert.match(html, /id="file-forward"[^>]*data-i18n-title="forward"[^>]*disabled/)
|
||
assert.match(html, /id="file-up"[^>]*disabled/)
|
||
assert.match(script, /let fileFuture = \[\]/)
|
||
assert.match(script, /elements\['file-forward'\]\.disabled = fileLoading \|\| fileFuture\.length === 0/)
|
||
assert.match(script, /elements\['file-up'\]\.disabled = fileLoading \|\| filePath === '\/'/)
|
||
assert.match(script, /fileHistory\.push\(filePath\)[\s\S]*fileFuture = \[\]/)
|
||
assert.match(script, /elements\['file-forward'\]\.addEventListener\('click', async/)
|
||
assert.match(style, /\.file-pathbar \.file-nav-button \{[^}]*display: grid[^}]*place-items: center[^}]*width: 34px[^}]*height: 34px/)
|
||
assert.match(style, /\.file-nav-icon \{[^}]*width: 8px[^}]*height: 14px[^}]*clip-path: polygon/)
|
||
assert.match(style, /\.file-editor-frame \{[\s\S]*grid-template-columns: auto minmax\(0, 1fr\)/)
|
||
assert.match(style, /@media \(max-width: 640px\)[\s\S]*\.file-table thead th:nth-child/)
|
||
assert.doesNotMatch(style, /\.file-load-more \{[^}]*!important/)
|
||
assert.doesNotMatch(pluginSource, /files\/list|filesTab|文件管理/)
|
||
assert.match(style, /\.terminal-frame \{[\s\S]*max-height: min\(760px, 78dvh\);[\s\S]*aspect-ratio: 16 \/ 9;/)
|
||
assert.match(style, /\.file-browser \{[^}]*max-height: min\(760px, 78dvh\);[^}]*aspect-ratio: 16 \/ 9;/)
|
||
assert.match(style, /@media \(max-width: 640px\)[\s\S]*\.terminal-frame \{ height: clamp\(300px, 56dvh, 440px\);[^}]*aspect-ratio: auto; \}/)
|
||
assert.match(style, /@media \(max-width: 640px\)[\s\S]*\.file-main \{[^}]*min-height: 300px;[^}]*max-height: 60dvh;/)
|
||
assert.match(script, /userPluginsTab: '用户插件'/)
|
||
assert.match(script, /userPluginsTab: 'User plugins'/)
|
||
assert.match(script, /skillsTab: '系统技能'/)
|
||
assert.match(script, /skillsTab: 'System skills'/)
|
||
assert.match(html, /id="tab-skills"/)
|
||
assert.match(html, /id="panel-skills"/)
|
||
assert.match(script, /function renderSystemSkills\(values, busy\)/)
|
||
assert.match(script, /skill\.id, action/)
|
||
assert.match(script, /applyUserPluginChanges: '应用并重新启动 DSH'/)
|
||
assert.match(script, /applyUserPluginChangesOffline: '应用修改'/)
|
||
assert.match(script, /applyUserPluginChanges: 'Apply and restart DSH'/)
|
||
assert.match(script, /applyUserPluginChangesOffline: 'Apply changes'/)
|
||
assert.match(script, /userPluginRecoveryDetail: 'DSH 启动或运行失败，但你仍可修改用户插件。故障日志可前往“运行维护”查看。'/)
|
||
assert.match(script, /systemPluginRecoveryDetail: 'DSH 启动或运行失败，但你仍可修改系统插件。故障日志可前往“运行维护”查看。'/)
|
||
assert.match(script, /systemSkillRecoveryDetail: 'DSH 启动或运行失败，但你仍可修改系统技能。故障日志可前往“运行维护”查看。'/)
|
||
assert.match(script, /userSkillRecoveryDetail: 'DSH 启动或运行失败，但你仍可修改用户技能。故障日志可前往“运行维护”查看。'/)
|
||
assert.doesNotMatch(script, /localizedError\(recoveryReason\)/)
|
||
for (const id of ['system-plugin-recovery', 'system-skill-recovery', 'user-skill-recovery', 'user-plugin-recovery']) {
|
||
assert.match(html, new RegExp(`id="${id}"`))
|
||
}
|
||
assert.match(script, /operation\.strategy === 'next-start'[\s\S]*systemPluginApplyingDraft\.clear\(\)/)
|
||
assert.match(script, /!dshUnavailable && plugins\.some\(plugin => plugin\.pendingRestart\)/)
|
||
assert.match(script, /const userPluginDraft = new Map\(\)/)
|
||
assert.match(script, /expandedUserPluginDescriptions/)
|
||
assert.match(script, /plugin\.description/)
|
||
assert.match(script, /description\.scrollWidth > description\.clientWidth/)
|
||
assert.match(script, /revision: userPluginInventory\.revision/)
|
||
assert.match(script, /error\.statusCode === 409[\s\S]*userPluginDraft\.clear\(\)[\s\S]*userPluginRevisionConflict/)
|
||
assert.match(script, /waitForUserPluginTask[\s\S]*catch \(error\)[\s\S]*lastError = error/)
|
||
assert.match(script, /userPluginPhaseRestoring: '正在恢复 Web Profile'/)
|
||
assert.match(script, /userPluginPhaseRestoring: 'Restoring Web Profile'/)
|
||
assert.doesNotMatch(script, /(?:localStorage|sessionStorage).*user-plugin-draft/)
|
||
assert.match(html, /id="user-plugin-recovery"/)
|
||
assert.match(html, /id="user-plugin-draft-actions"[^>]*hidden/)
|
||
assert.match(html, /id="cancel-user-plugin-changes"/)
|
||
assert.match(html, /id="apply-user-plugin-changes"/)
|
||
assert.match(script, /user-plugin-draft-actions'\]\.hidden = count === 0 && !restartRequired/)
|
||
assert.match(script, /const dshUnavailable = status\?\.recoveryMode[\s\S]*applyUserPluginChangesOffline/)
|
||
assert.doesNotMatch(style, /\.draft-actions/)
|
||
assert.match(style, /\.tabs \{[\s\S]*width: 100%;[\s\S]*min-width: 0;[\s\S]*max-width: 100%;[\s\S]*overflow-x: auto/)
|
||
assert.match(style, /\.resource-panel \{ padding-bottom: 0; overflow-x: hidden; overflow-y: auto; overflow-anchor: none; \}/)
|
||
assert.match(style, /\.resource-panel > section \{ height: 100%; min-height: 0; overflow: visible; \}/)
|
||
assert.match(style, /\.resource-panel \.resource-section-heading,[\s\S]*\.resource-panel \.list-pagination,[\s\S]*\.resource-panel \.operation-result \{ flex: none; \}/)
|
||
assert.match(style, /@media \(max-height: 600px\) \{\s*\.resource-panel > section \{ gap: 8px; padding: 12px 0; \}/)
|
||
assert.match(style, /\.resource-panel \.plugin-list, \.resource-panel \.user-plugin-list \{[\s\S]*max-height: min\(52dvh, 520px\);[\s\S]*flex: 0 1 auto;[\s\S]*overflow-y: auto;[\s\S]*overflow-anchor: none;[\s\S]*scrollbar-gutter: stable/)
|
||
assert.doesNotMatch(style, /\.resource-panel \.plugin-list, \.resource-panel \.user-plugin-list \{ max-height: min\(calc\(56\.25vw/)
|
||
assert.match(style, /@media \(hover: hover\) and \(pointer: fine\) \{\s*\.tabs \{ scroll-snap-type: none; \}/)
|
||
assert.match(script, /function makeHorizontalTabStripScrollable\(tablist\)/)
|
||
assert.match(script, /const stableScrollPositions = new WeakMap\(\)[\s\S]*if \(scrollRestoreGenerations\.has\(element\)\) return[\s\S]*scrollRestoreGenerations\.get\(current\) !== generation/)
|
||
assert.match(script, /function preserveResourceRowPosition\(element, update\)[\s\S]*closest\('\.resource-panel'\)[\s\S]*current === panel\) break[\s\S]*current\.scrollTop \+= offset/)
|
||
assert.match(script, /checkbox\.addEventListener\('change', event => preserveResourceRowPosition\(event\.currentTarget, \(\) => setSystemPluginDraft/)
|
||
assert.match(script, /checkbox\.addEventListener\('change', event => preserveResourceRowPosition\(event\.currentTarget, \(\) => setUserPluginDraft/)
|
||
assert.doesNotMatch(script, /scrollIntoView\(\{ block: 'nearest', inline: 'nearest' \}\)/)
|
||
assert.match(script, /const tablist = activeTab\.parentElement[\s\S]*tablist\.scrollLeft = right - tablist\.clientWidth/)
|
||
assert.match(script, /addEventListener\('wheel',[\s\S]*\{ passive: false \}\)/)
|
||
assert.match(script, /if \(event\.deltaX !== 0\) return/)
|
||
assert.match(script, /requestAnimationFrame\(animateWheel\)/)
|
||
assert.match(script, /addEventListener\('pointermove'/)
|
||
assert.match(script, /if \(Math\.abs\(distance\) >= 4 && !dragged\) \{\s*dragged = true\s*tablist\.setPointerCapture\?\.\(pointerId\)/)
|
||
assert.doesNotMatch(script, /dragTarget = event\.target\s*tablist\.setPointerCapture/)
|
||
assert.match(script, /const displacedClickTarget = !dragged && event\.target !== dragTarget \? dragTarget : undefined[\s\S]*displacedClickTarget\?\.click\(\)/)
|
||
assert.match(script, /makeHorizontalTabStripScrollable\(document\.querySelector\('\.tabs'\)\)/)
|
||
assert.match(style, /\.topbar-inner \{[\s\S]*width: min\(1180px, calc\(100% - 48px\)\)/)
|
||
assert.match(style, /main \{[\s\S]*width: min\(1180px, calc\(100% - 48px\)\)/)
|
||
assert.match(style, /:root\[data-theme="dark"\][\s\S]*@media \(prefers-color-scheme: dark\)[\s\S]*:root:not\(\[data-theme\]\)/)
|
||
assert.match(style, /\.topbar-actions \{[^}]*display: flex/)
|
||
assert.match(style, /@media \(max-width: 640px\)/)
|
||
assert.match(style, /\.log-resize-frame \{[^}]*height: 480px;[^}]*min-height: 140px;[^}]*max-height: min\(1080px, 105dvh\);/)
|
||
assert.match(style, /\.log-resize-handle \{[^}]*height: 16px;[^}]*cursor: ns-resize;/)
|
||
assert.match(script, /makeLogListVerticallyResizable\(elements\['log-resize-frame'\], elements\['log-resize-handle'\]\)/)
|
||
assert.match(script, /element\.style\.height = `\$\{String\(height\)\}px`/)
|
||
assert.match(script, /scrollContainer\.scrollTop \+= Math\.min\(overflow, 24\)/)
|
||
assert.match(style, /@media \(max-width: 640px\)[\s\S]*\.log-resize-frame \{ height: min\(260px, 36dvh\); \}/)
|
||
assert.match(style, /\.log-entry \.log-details/)
|
||
assert.match(style, /\.log-entry\[aria-expanded='true'\] \.log-chevron/)
|
||
assert.match(style, /\.log-entry\[aria-expanded='false'\] \.log-message-row > pre \{[^}]*white-space: nowrap;/)
|
||
assert.match(style, /\.log-chevron::before \{[^}]*width: 8px[^}]*height: 5px[^}]*clip-path: polygon[^}]*transform-origin: center/)
|
||
assert.match(style, /\.log-chevron \{[^}]*top: 2px/)
|
||
assert.doesNotMatch(style, /\.log-chevron(?:::before)? \{[^}]*transition:/)
|
||
assert.match(style, /\.log-entry\[aria-expanded='true'\] \.log-chevron::before \{[^}]*transform: rotate\(180deg\)/)
|
||
assert.match(style, /\.user-plugin-description\.expanded/)
|
||
assert.match(style, /\.resource-description\.expanded/)
|
||
assert.match(style, /\.plugin-row \{[^}]*min-height:\s*52px/)
|
||
assert.match(script, /function commitFilePageJump[\s\S]*Math\.min\(lastPage, Math\.max\(0, requested - 1\)\)[\s\S]*input\.value = String\(page \+ 1\)/)
|
||
assert.match(style, /\.plugin-actions \.toggle \{ width: auto; \}/)
|
||
assert.match(style, /button\.compact \{[^}]*border-radius: 6px;/)
|
||
assert.match(style, /\.user-plugin-badge \{[^}]*border-radius: 4px;/)
|
||
assert.match(style, /\.proxy-provider-heading > h2 \{[^}]*font-size: 16px;[^}]*line-height: 24px;/)
|
||
assert.match(style, /\.user-plugin-row \{[\s\S]*grid-template-columns: minmax\(0, 1fr\) auto/)
|
||
assert.match(style, /@media \(max-width: 640px\)[\s\S]*\.user-plugin-row \{ grid-template-columns: 1fr/)
|
||
})
|
||
|
||
test('production Management wires Runtime reset to the Bootstrap control boundary', async () => {
|
||
const source = await readFile(new URL('../../control-plane/services/management/index.mjs', import.meta.url), 'utf8')
|
||
const serverStart = source.indexOf('server = createManagementServer({')
|
||
assert.notEqual(serverStart, -1)
|
||
const serverSource = source.slice(serverStart)
|
||
assert.match(serverSource, /resetRuntime: \(\) => bootstrap\.request\('POST', '\/v1\/deployments\/runtime\/reset'\)/)
|
||
})
|
||
|
||
test('CLI parser keeps rollback local and update wait behavior explicit', async () => {
|
||
assert.deepEqual(parseCli(['update', '--wait']), { command: 'update', wait: true })
|
||
assert.deepEqual(parseCli(['trust', 'status']), { command: 'trust', operation: 'status' })
|
||
assert.throws(() => parseCli(['update', '--force']))
|
||
const calls = []
|
||
const output = []
|
||
const management = {
|
||
request: async (method, path, body) => {
|
||
calls.push({ method, path, body })
|
||
if (path.endsWith('/rollback-plan')) return { plan: { planId: 'plan-a' } }
|
||
return path.endsWith('/rollback') ? { taskId: 'rollback-task' } : {}
|
||
},
|
||
}
|
||
assert.equal(await runCli({ argv: ['rollback'], management, write: line => output.push(line) }), 0)
|
||
assert.deepEqual(calls, [
|
||
{ method: 'GET', path: '/_dsh_platform/api/v1/rollback-plan', body: undefined },
|
||
{ method: 'POST', path: '/_dsh_platform/api/v1/rollback', body: { planId: 'plan-a' } },
|
||
])
|
||
assert.match(output[0], /rollback-task/)
|
||
})
|
||
|
||
test('management CLI creates a root-only one-time authentication reset key', async () => {
|
||
assert.deepEqual(parseCli(['access', 'generate-key']), { command: 'access', operation: 'generate-key' })
|
||
assert.throws(() => parseCli(['access', 'create']))
|
||
assert.throws(() => parseCli(['access']))
|
||
const calls = []
|
||
const output = []
|
||
const tty = { isTTY: true }
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'generate-key'],
|
||
access: {
|
||
request: async (method, path) => {
|
||
calls.push([method, path])
|
||
if (method === 'GET') return { state: 'migration-required', account: null }
|
||
return { key: 'dshak_example', expiresAt: '2026-08-28T00:10:00.000Z' }
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async () => 'y',
|
||
write: line => output.push(line),
|
||
}), 0)
|
||
assert.deepEqual(calls, [
|
||
['GET', '/v1/recovery/status'],
|
||
['POST', '/v1/recovery/generate-key'],
|
||
])
|
||
assert.deepEqual(JSON.parse(output[0]), {
|
||
key: 'dshak_example', expiresAt: '2026-08-28T00:10:00.000Z',
|
||
})
|
||
await assert.rejects(runCli({
|
||
argv: ['access', 'generate-key'], access: { request: async () => ({}) },
|
||
getuid: () => 1000, input: tty, output: tty,
|
||
}), /requires root/)
|
||
})
|
||
|
||
test('management CLI exposes standalone two-factor disable without session logout', async () => {
|
||
assert.deepEqual(parseCli(['access', 'disable-two-factor']), {
|
||
command: 'access', operation: 'disable-two-factor',
|
||
})
|
||
const calls = []
|
||
const tty = { isTTY: true }
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'disable-two-factor'],
|
||
access: { request: async (method, path, body) => {
|
||
calls.push({ method, path, body })
|
||
if (method === 'GET') return { state: 'initialized', account: { revision: 'revision-a' } }
|
||
return { account: { revision: 'revision-b' }, allSessionsRevoked: false }
|
||
} },
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async prompt => { assert.equal(prompt, 'Disable two-factor authentication? y/[n]: '); return 'y' },
|
||
write: () => {},
|
||
}), 0)
|
||
assert.deepEqual(calls, [
|
||
{ method: 'GET', path: '/v1/recovery/status', body: undefined },
|
||
{ method: 'POST', path: '/v1/recovery/reset-access', body: {
|
||
revision: 'revision-a', managementPasswordAction: 'preserve', totpAction: 'disable',
|
||
} },
|
||
])
|
||
})
|
||
|
||
test('management CLI clears all or only Management sessions', async () => {
|
||
assert.deepEqual(parseCli(['access', 'clear-sessions']), {
|
||
command: 'access', operation: 'clear-sessions',
|
||
})
|
||
assert.deepEqual(parseCli(['access', 'clear-sessions', '--management-only']), {
|
||
command: 'access', operation: 'clear-sessions', managementOnly: true,
|
||
})
|
||
const tty = { isTTY: true }
|
||
for (const [argv, expectedScope] of [
|
||
[['access', 'clear-sessions'], false],
|
||
[['access', 'clear-sessions', '--management-only'], true],
|
||
]) {
|
||
let submitted
|
||
await runCli({
|
||
argv,
|
||
access: { request: async (method, path, body) => {
|
||
if (method === 'GET') return { state: 'initialized', account: { revision: 'revision-a' } }
|
||
submitted = { method, path, body }
|
||
return { status: 'cleared' }
|
||
} },
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async () => 'y',
|
||
write: () => {},
|
||
})
|
||
assert.deepEqual(submitted, {
|
||
method: 'POST', path: '/v1/recovery/clear-sessions', body: { managementOnly: expectedScope },
|
||
})
|
||
}
|
||
})
|
||
|
||
test('management CLI clears login retry wait only after Root TTY confirmation', async () => {
|
||
assert.deepEqual(parseCli(['access', 'clear-retry']), { command: 'access', operation: 'clear-retry' })
|
||
assert.deepEqual(parseCli(['access', 'clear-retry', '--global-only']), {
|
||
command: 'access', operation: 'clear-retry', globalOnly: true,
|
||
})
|
||
assert.deepEqual(parseCli(['access', 'clear-retry', '--two-factor']), {
|
||
command: 'access', operation: 'clear-retry', credential: 'totp',
|
||
})
|
||
assert.deepEqual(parseCli(['access', 'clear-retry', '--global-only', '--two-factor']), {
|
||
command: 'access', operation: 'clear-retry', globalOnly: true, credential: 'totp',
|
||
})
|
||
assert.throws(() => parseCli(['access', 'clear-retry', 'now']))
|
||
const tty = { isTTY: true }
|
||
const calls = []
|
||
const output = []
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'clear-retry'],
|
||
access: {
|
||
request: async (method, path, body) => {
|
||
calls.push([method, path, body])
|
||
if (method === 'GET') return {
|
||
state: 'initialized',
|
||
authenticationRetry: { consecutiveFailures: 5, retryAfterSeconds: 1 },
|
||
account: { revision: 'revision-a' },
|
||
}
|
||
return {
|
||
status: 'cleared', scope: 'all', cleared: true, activeSources: 1,
|
||
consecutiveFailures: 5, retryAfterSeconds: 1,
|
||
sourceRetryAfterSeconds: 0, globalFailures: 5, globalRetryAfterSeconds: 0,
|
||
}
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async prompt => {
|
||
assert.equal(prompt, 'Clear all administrator login retry limits? y/[n]: ')
|
||
return 'y'
|
||
},
|
||
write: line => output.push(line),
|
||
}), 0)
|
||
assert.deepEqual(calls, [
|
||
['GET', '/v1/recovery/status', undefined],
|
||
['POST', '/v1/recovery/clear-retry', { scope: 'all' }],
|
||
])
|
||
assert.deepEqual(JSON.parse(output[0]), {
|
||
status: 'cleared', scope: 'all', cleared: true, activeSources: 1,
|
||
consecutiveFailures: 5, retryAfterSeconds: 1,
|
||
sourceRetryAfterSeconds: 0, globalFailures: 5, globalRetryAfterSeconds: 0,
|
||
})
|
||
await assert.rejects(runCli({
|
||
argv: ['access', 'clear-retry'], access: { request: async () => ({}) },
|
||
getuid: () => 1000, input: tty, output: tty,
|
||
}), /requires root/)
|
||
await assert.rejects(runCli({
|
||
argv: ['access', 'clear-retry'], access: { request: async () => ({}) },
|
||
getuid: () => 0, input: { isTTY: false }, output: tty,
|
||
}), /interactive container console/)
|
||
|
||
const globalCalls = []
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'clear-retry', '--global-only'],
|
||
access: {
|
||
request: async (method, path, body) => {
|
||
globalCalls.push([method, path, body])
|
||
if (method === 'GET') return { state: 'initialized', account: { revision: 'revision-a' } }
|
||
return { status: 'cleared', scope: 'global', cleared: true, globalFailures: 20 }
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async prompt => {
|
||
assert.equal(prompt, 'Clear instance-wide administrator login rate limits? y/[n]: ')
|
||
return 'y'
|
||
},
|
||
write: () => {},
|
||
}), 0)
|
||
assert.deepEqual(globalCalls, [
|
||
['GET', '/v1/recovery/status', undefined],
|
||
['POST', '/v1/recovery/clear-retry', { scope: 'global' }],
|
||
])
|
||
|
||
const totpCalls = []
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'clear-retry', '--two-factor'],
|
||
access: { request: async (method, path, body) => {
|
||
totpCalls.push([method, path, body])
|
||
return method === 'GET'
|
||
? { state: 'initialized', account: { revision: 'revision-a' } }
|
||
: { status: 'cleared', scope: 'all', credential: 'totp', cleared: 2 }
|
||
} },
|
||
getuid: () => 0, input: tty, output: tty,
|
||
ask: async prompt => {
|
||
assert.equal(prompt, 'Clear two-factor daily limits? The fixed 10-second retry remains active. y/[n]: ')
|
||
return 'y'
|
||
},
|
||
write: () => {},
|
||
}), 0)
|
||
assert.deepEqual(totpCalls, [
|
||
['GET', '/v1/recovery/status', undefined],
|
||
['POST', '/v1/recovery/clear-retry', { scope: 'all', credential: 'totp' }],
|
||
])
|
||
})
|
||
|
||
test('access clear-retry accepts only retry scope and credential selectors', async () => {
|
||
assert.deepEqual(parseCli(['access', 'clear-retry']), {
|
||
command: 'access', operation: 'clear-retry',
|
||
})
|
||
assert.deepEqual(parseCli(['access', 'clear-retry', '--main-password']), {
|
||
command: 'access', operation: 'clear-retry', credential: 'main',
|
||
})
|
||
assert.deepEqual(parseCli(['access', 'clear-retry', '--two-factor']), {
|
||
command: 'access', operation: 'clear-retry', credential: 'totp',
|
||
})
|
||
assert.throws(
|
||
() => parseCli(['access', 'clear-retry', '--main-password', '--management-password']),
|
||
error => error.message.includes('\ncommands:\n')
|
||
&& error.message.includes('access clear-retry [--global-only] [--main-password|--management-password|--two-factor]'),
|
||
)
|
||
let recoverError
|
||
let commandError
|
||
try { parseCli(['access', 'clear-retry', '--bad-option']) } catch (error) { recoverError = error }
|
||
try { parseCli(['unknown-command']) } catch (error) { commandError = error }
|
||
assert.equal(recoverError.message, commandError.message)
|
||
assert.match(recoverError.message, /^usage: dsh-platform <command> \[options\]\ncommands:\n/)
|
||
assert.doesNotMatch(recoverError.message, /requires --image-baseline/)
|
||
const tty = { isTTY: true }
|
||
const calls = []
|
||
const output = []
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'clear-retry', '--management-password'],
|
||
access: { request: async (method, path, body) => {
|
||
calls.push(['access', method, path, body])
|
||
return { status: 'cleared', scope: 'all', credential: 'management', cleared: true }
|
||
} },
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async prompt => {
|
||
assert.equal(prompt, 'Clear Management console password login retry limits? y/[n]: ')
|
||
return 'y'
|
||
},
|
||
write: line => output.push(line),
|
||
}), 0)
|
||
assert.deepEqual(calls, [
|
||
['access', 'GET', '/v1/recovery/status', undefined],
|
||
['access', 'POST', '/v1/recovery/clear-retry', { scope: 'all', credential: 'management' }],
|
||
])
|
||
assert.deepEqual(JSON.parse(output[0]), { status: 'cleared', scope: 'all', credential: 'management', cleared: true })
|
||
})
|
||
|
||
test('hidden access input preserves the TTY stream for subsequent prompts', async () => {
|
||
const input = new PassThrough()
|
||
input.isTTY = true
|
||
input.setRawMode = value => { input.isRaw = value }
|
||
const output = new PassThrough()
|
||
output.isTTY = true
|
||
const first = readSecret(input, output, 'First password: ')
|
||
input.write('first secret\n')
|
||
assert.equal(await first, 'first secret')
|
||
assert.equal(input.destroyed, false)
|
||
assert.equal(input.isRaw, false)
|
||
const second = readSecret(input, output, 'Second password: ')
|
||
input.write('second secret\n')
|
||
assert.equal(await second, 'second secret')
|
||
assert.equal(input.destroyed, false)
|
||
assert.equal(input.isRaw, false)
|
||
})
|
||
|
||
test('management CLI defaults every direct access mutation to no', async () => {
|
||
const tty = { isTTY: true }
|
||
for (const operation of [
|
||
'set-username',
|
||
'reset-password',
|
||
'reset-management-password',
|
||
'disable-management-password',
|
||
'generate-key',
|
||
'clear-retry',
|
||
]) {
|
||
const calls = []
|
||
const prompts = []
|
||
const output = []
|
||
assert.equal(await runCli({
|
||
argv: ['access', operation],
|
||
access: {
|
||
request: async (method, path, body) => {
|
||
calls.push({ method, path, body })
|
||
return {
|
||
state: 'initialized',
|
||
account: {
|
||
revision: 'revision-a',
|
||
managementAdditionalCredential: { enabled: true, version: 2 },
|
||
},
|
||
}
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async prompt => {
|
||
prompts.push(prompt)
|
||
return ''
|
||
},
|
||
readPassword: async () => { throw new Error('password must not be requested') },
|
||
write: line => output.push(line),
|
||
}), 0)
|
||
assert.deepEqual(calls, [
|
||
{ method: 'GET', path: '/v1/recovery/status', body: undefined },
|
||
])
|
||
assert.equal(prompts.length, 1)
|
||
assert.match(prompts[0], /y\/\[n\]: $/)
|
||
assert.deepEqual(JSON.parse(output[0]), { status: 'cancelled' })
|
||
}
|
||
})
|
||
|
||
test('management CLI resets administrator access through one atomic recovery request', async () => {
|
||
assert.deepEqual(parseCli(['access', 'reset']), { command: 'access', operation: 'reset' })
|
||
const calls = []
|
||
const prompts = []
|
||
const output = []
|
||
const passwords = ['new administrator password', 'new management password']
|
||
const answers = ['y', 'operator', 'y', 'y', 'y']
|
||
const tty = { isTTY: true }
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'reset'],
|
||
access: {
|
||
request: async (method, path, body) => {
|
||
calls.push({ method, path, body })
|
||
if (method === 'GET') return {
|
||
state: 'initialized',
|
||
account: {
|
||
revision: 'revision-a',
|
||
managementAdditionalCredential: { enabled: true, version: 2 },
|
||
totp: { enabled: true, version: 1 },
|
||
},
|
||
}
|
||
return { account: { revision: 'revision-b', mainCredentialVersion: 2 } }
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
readPassword: async (_input, _output, prompt) => {
|
||
prompts.push(prompt)
|
||
return passwords.shift()
|
||
},
|
||
ask: async prompt => {
|
||
prompts.push(prompt)
|
||
return answers.shift()
|
||
},
|
||
write: line => output.push(line),
|
||
}), 0)
|
||
assert.deepEqual(prompts, [
|
||
'Change administrator username? y/[n]: ',
|
||
'New administrator username: ',
|
||
'Change administrator password? y/[n]: ',
|
||
'New administrator password: ',
|
||
'Change Management console password? (y)es/[n]o/(d)isable: ',
|
||
'New management password: ',
|
||
'Disable two-factor authentication? y/[n]: ',
|
||
])
|
||
assert.deepEqual(calls, [
|
||
{ method: 'GET', path: '/v1/recovery/status', body: undefined },
|
||
{
|
||
method: 'POST',
|
||
path: '/v1/recovery/reset-access',
|
||
body: {
|
||
revision: 'revision-a',
|
||
username: 'operator',
|
||
password: 'new administrator password',
|
||
managementPasswordAction: 'reset',
|
||
managementPassword: 'new management password',
|
||
totpAction: 'disable',
|
||
},
|
||
},
|
||
])
|
||
assert.equal(JSON.parse(output[0]).account.mainCredentialVersion, 2)
|
||
})
|
||
|
||
test('management CLI skips the additional-password choice when it is disabled', async () => {
|
||
const calls = []
|
||
const answers = ['n', 'y']
|
||
const tty = { isTTY: true }
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'reset'],
|
||
access: {
|
||
request: async (method, path, body) => {
|
||
calls.push({ method, path, body })
|
||
if (method === 'GET') return {
|
||
state: 'initialized',
|
||
account: {
|
||
revision: 'revision-a',
|
||
managementAdditionalCredential: { enabled: false, version: 1 },
|
||
},
|
||
}
|
||
return { account: { revision: 'revision-b' } }
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
readPassword: async () => 'new administrator password',
|
||
ask: async () => answers.shift(),
|
||
write: () => {},
|
||
}), 0)
|
||
assert.deepEqual(calls.at(-1), {
|
||
method: 'POST',
|
||
path: '/v1/recovery/reset-access',
|
||
body: {
|
||
revision: 'revision-a',
|
||
password: 'new administrator password',
|
||
managementPasswordAction: 'preserve',
|
||
},
|
||
})
|
||
})
|
||
|
||
test('management CLI preserves or disables an existing additional password by choice', async () => {
|
||
const tty = { isTTY: true }
|
||
for (const [choice, action] of [['', 'preserve'], ['d', 'disable']]) {
|
||
let submitted
|
||
const answers = ['n', 'y', choice]
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'reset'],
|
||
access: {
|
||
request: async (method, _path, body) => {
|
||
if (method === 'GET') return {
|
||
state: 'initialized',
|
||
account: {
|
||
revision: 'revision-a',
|
||
managementAdditionalCredential: { enabled: true, version: 2 },
|
||
},
|
||
}
|
||
submitted = body
|
||
return { account: { revision: 'revision-b' } }
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
readPassword: async () => 'new administrator password',
|
||
ask: async () => answers.shift(),
|
||
write: () => {},
|
||
}), 0)
|
||
assert.equal(submitted.managementPasswordAction, action)
|
||
assert.equal('managementPassword' in submitted, false)
|
||
}
|
||
})
|
||
|
||
test('management CLI combined reset can disable only two-factor authentication', async () => {
|
||
const calls = []
|
||
const answers = ['n', 'n', 'n', 'y']
|
||
const tty = { isTTY: true }
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'reset'],
|
||
access: {
|
||
request: async (method, path, body) => {
|
||
calls.push({ method, path, body })
|
||
if (method === 'GET') return {
|
||
state: 'initialized',
|
||
account: {
|
||
revision: 'revision-a',
|
||
managementAdditionalCredential: { enabled: true, version: 2 },
|
||
totp: { enabled: true, version: 1 },
|
||
},
|
||
}
|
||
return { account: { revision: 'revision-b', totp: { enabled: false, version: 2 } } }
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async () => answers.shift(),
|
||
write: () => {},
|
||
}), 0)
|
||
assert.deepEqual(calls.at(-1), {
|
||
method: 'POST',
|
||
path: '/v1/recovery/reset-access',
|
||
body: {
|
||
revision: 'revision-a',
|
||
managementPasswordAction: 'preserve',
|
||
totpAction: 'disable',
|
||
},
|
||
})
|
||
})
|
||
|
||
test('management CLI rejects ambiguous choices and cancels an empty combined reset', async () => {
|
||
const tty = { isTTY: true }
|
||
for (const answers of [['yes'], ['n', 'n', 'invalid']]) {
|
||
const calls = []
|
||
await assert.rejects(runCli({
|
||
argv: ['access', 'reset'],
|
||
access: {
|
||
request: async (method, path, body) => {
|
||
calls.push({ method, path, body })
|
||
return {
|
||
state: 'initialized',
|
||
account: {
|
||
revision: 'revision-a',
|
||
managementAdditionalCredential: { enabled: true, version: 2 },
|
||
},
|
||
}
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async () => answers.shift(),
|
||
readPassword: async () => { throw new Error('password must not be requested') },
|
||
write: () => {},
|
||
}), /choice must be y or n|management password choice must be y, n, or d/)
|
||
assert.deepEqual(calls, [
|
||
{ method: 'GET', path: '/v1/recovery/status', body: undefined },
|
||
])
|
||
}
|
||
|
||
const calls = []
|
||
const output = []
|
||
const answers = ['n', 'n', '']
|
||
assert.equal(await runCli({
|
||
argv: ['access', 'reset'],
|
||
access: {
|
||
request: async (method, path, body) => {
|
||
calls.push({ method, path, body })
|
||
return {
|
||
state: 'initialized',
|
||
account: {
|
||
revision: 'revision-a',
|
||
managementAdditionalCredential: { enabled: true, version: 2 },
|
||
},
|
||
}
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async () => answers.shift(),
|
||
write: line => output.push(line),
|
||
}), 0)
|
||
assert.deepEqual(calls, [
|
||
{ method: 'GET', path: '/v1/recovery/status', body: undefined },
|
||
])
|
||
assert.deepEqual(JSON.parse(output[0]), { status: 'cancelled' })
|
||
})
|
||
|
||
test('management CLI does not submit partially collected access recovery input', async () => {
|
||
const calls = []
|
||
const answers = ['y', 'operator', 'y']
|
||
const tty = { isTTY: true }
|
||
await assert.rejects(runCli({
|
||
argv: ['access', 'reset'],
|
||
access: {
|
||
request: async (method, path, body) => {
|
||
calls.push({ method, path, body })
|
||
return {
|
||
state: 'initialized',
|
||
account: {
|
||
revision: 'revision-a',
|
||
managementAdditionalCredential: { enabled: true, version: 2 },
|
||
},
|
||
}
|
||
},
|
||
},
|
||
getuid: () => 0,
|
||
input: tty,
|
||
output: tty,
|
||
ask: async () => answers.shift(),
|
||
readPassword: async () => { throw new Error('access recovery cancelled') },
|
||
write: () => {},
|
||
}), /access recovery cancelled/)
|
||
assert.deepEqual(calls, [
|
||
{ method: 'GET', path: '/v1/recovery/status', body: undefined },
|
||
])
|
||
})
|
||
|
||
test('update wait ignores a terminal state from an older task', async () => {
|
||
const output = []
|
||
const statuses = [
|
||
{ update: { taskId: 'old-task', status: 'failed' } },
|
||
{ update: { taskId: 'new-task', status: 'planning' } },
|
||
{ update: { taskId: 'new-task', status: 'success' } },
|
||
]
|
||
const management = {
|
||
request: async (method, path) => {
|
||
if (method === 'POST' && path.endsWith('/update')) return { taskId: 'new-task' }
|
||
return statuses.shift()
|
||
},
|
||
}
|
||
let waits = 0
|
||
const exitCode = await runCli({
|
||
argv: ['update', '--wait'],
|
||
management,
|
||
write: line => output.push(line),
|
||
delay: async () => { waits += 1 },
|
||
})
|
||
assert.equal(exitCode, 0)
|
||
assert.equal(waits, 2)
|
||
assert.match(output.at(-1), /new-task/)
|
||
})
|
||
|
||
test('update wait reconnects across a Bootstrap handoff and follows the resumed task', async () => {
|
||
const output = []
|
||
const unavailable = Object.assign(new Error('management socket is restarting'), { code: 'ENOENT' })
|
||
const statuses = [
|
||
unavailable,
|
||
{ update: { taskId: 'resumed-task', operation: 'update', status: 'planning' } },
|
||
{ update: { taskId: 'resumed-task', operation: 'update', status: 'success' } },
|
||
]
|
||
const management = {
|
||
request: async (method, path) => {
|
||
if (method === 'POST' && path.endsWith('/update')) return { taskId: 'original-task' }
|
||
const next = statuses.shift()
|
||
if (next instanceof Error) throw next
|
||
return next
|
||
},
|
||
}
|
||
let waits = 0
|
||
const exitCode = await runCli({
|
||
argv: ['update', '--wait'],
|
||
management,
|
||
write: line => output.push(line),
|
||
delay: async () => { waits += 1 },
|
||
})
|
||
assert.equal(exitCode, 0)
|
||
assert.equal(waits, 2)
|
||
assert.match(output.at(-1), /resumed-task/)
|
||
})
|
||
|
||
test('update wait does not hide non-transient Management failures', async () => {
|
||
const management = {
|
||
request: async method => {
|
||
if (method === 'POST') return { taskId: 'original-task' }
|
||
throw Object.assign(new Error('permission denied'), { code: 'EACCES' })
|
||
},
|
||
}
|
||
await assert.rejects(runCli({
|
||
argv: ['update', '--wait'], management, write: () => {}, delay: async () => {},
|
||
}), /permission denied/)
|
||
})
|
||
|
||
test('management CLI emits each JSON result as one log-safe line', async () => {
|
||
const output = []
|
||
const status = {
|
||
officialDshVersion: null,
|
||
dshLifecycle: {
|
||
state: 'running', action: null, taskId: null, attempt: 0, maxAttempts: 3,
|
||
error: null, updatedAt: null,
|
||
},
|
||
}
|
||
assert.equal(await runCli({
|
||
argv: ['status'],
|
||
management: { request: async () => status },
|
||
write: line => output.push(line),
|
||
}), 0)
|
||
assert.deepEqual(output, [JSON.stringify(status)])
|
||
assert.equal(output[0].includes('\n'), false)
|
||
})
|
||
|
||
test('lifecycle CLI has a fixed DSH scope and waits only for its own task', async () => {
|
||
assert.deepEqual(parseCli(['start']), { command: 'start', wait: false })
|
||
assert.deepEqual(parseCli(['stop', '--wait']), { command: 'stop', wait: true })
|
||
assert.deepEqual(parseCli(['restart']), { command: 'restart', wait: false })
|
||
assert.deepEqual(parseCli(['restart', '--wait']), { command: 'restart', wait: true })
|
||
assert.throws(() => parseCli(['restart', 'gateway']))
|
||
assert.throws(() => parseCli(['restart', '--component', 'gateway']))
|
||
const immediateCalls = []
|
||
assert.equal(await runCli({
|
||
argv: ['restart'],
|
||
management: {
|
||
request: async (method, path) => {
|
||
immediateCalls.push([method, path])
|
||
return { taskId: 'immediate-task' }
|
||
},
|
||
},
|
||
write: () => {},
|
||
}), 0)
|
||
assert.deepEqual(immediateCalls, [['POST', '/_dsh_platform/api/v1/restart-dsh']])
|
||
const output = []
|
||
const statuses = [
|
||
{ dshLifecycle: { taskId: 'old-task', state: 'running' } },
|
||
{ dshLifecycle: { taskId: 'restart-task', state: 'restarting' } },
|
||
{ dshLifecycle: { taskId: 'restart-task', state: 'running' } },
|
||
]
|
||
const calls = []
|
||
const management = {
|
||
request: async (method, path) => {
|
||
calls.push([method, path])
|
||
if (method === 'POST') return { taskId: 'restart-task' }
|
||
return statuses.shift()
|
||
},
|
||
}
|
||
let waits = 0
|
||
const exitCode = await runCli({
|
||
argv: ['restart', '--wait'],
|
||
management,
|
||
write: line => output.push(line),
|
||
delay: async () => { waits += 1 },
|
||
})
|
||
assert.equal(exitCode, 0)
|
||
assert.equal(waits, 2)
|
||
assert.deepEqual(calls[0], ['POST', '/_dsh_platform/api/v1/restart-dsh'])
|
||
assert.match(output[0], /restart-task/)
|
||
assert.match(output.at(-1), /running/)
|
||
})
|
||
|
||
test('CLI parses channel controls and refuses noninteractive Stable return', async () => {
|
||
assert.deepEqual(parseCli(['channel', 'experimental']), { command: 'channel', channel: 'experimental' })
|
||
assert.deepEqual(parseCli(['retry']), { command: 'retry' })
|
||
assert.deepEqual(parseCli(['return-stable']), { command: 'return-stable' })
|
||
const management = {
|
||
request: async () => ({ plan: { planId: 'plan-a', snapshot: { createdAt: '2026-08-19T00:00:00.000Z' } } }),
|
||
}
|
||
await assert.rejects(runCli({
|
||
argv: ['return-stable'], management, input: { isTTY: false }, output: { isTTY: false }, write: () => {},
|
||
}), /interactive/)
|
||
})
|
||
|
||
test('trust reset refuses non-root and non-interactive callers before mutation', async () => {
|
||
await assert.rejects(resetTrust({ getuid: () => 1000 }), /root/)
|
||
await assert.rejects(resetTrust({ getuid: () => 0, input: { isTTY: false }, output: { isTTY: false } }), /interactive/)
|
||
})
|
||
|
||
test('image baseline recovery is root/TTY-only and requires the complete image identity', async () => {
|
||
assert.deepEqual(parseCli(['recover']), { command: 'recover' })
|
||
const calls = []
|
||
const recovery = {
|
||
request: async (method, path, body) => {
|
||
calls.push({ method, path, body })
|
||
if (method === 'GET') return { imageBaseline: { imageBuildId: `sha256:${'a'.repeat(64)}`, dsh: '0.1.0-rc.10' } }
|
||
return { status: 'recovered' }
|
||
},
|
||
}
|
||
await assert.rejects(recoverImageBaseline({ recovery, getuid: () => 1000 }), /root/)
|
||
await assert.rejects(recoverImageBaseline({
|
||
recovery, getuid: () => 0, input: { isTTY: false }, output: { isTTY: false },
|
||
}), /interactive/)
|
||
const expected = `RECOVER IMAGE BASELINE sha256:${'a'.repeat(64)}`
|
||
const value = await recoverImageBaseline({
|
||
recovery,
|
||
getuid: () => 0,
|
||
input: { isTTY: true },
|
||
output: { isTTY: true },
|
||
ask: async prompt => prompt,
|
||
})
|
||
assert.equal(value.status, 'recovered')
|
||
assert.deepEqual(calls, [
|
||
{ method: 'GET', path: '/v1/status', body: undefined },
|
||
{ method: 'POST', path: '/v1/recover-image-baseline', body: { confirm: expected.slice('RECOVER IMAGE BASELINE '.length) } },
|
||
])
|
||
})
|
||
|
||
test('scheduler applies bounded jitter and performs checks without activating updates', async () => {
|
||
let delay
|
||
let callback
|
||
let checks = 0
|
||
const scheduler = new UpdateScheduler({
|
||
check: async () => { checks += 1 },
|
||
intervalSeconds: 100,
|
||
random: () => 0,
|
||
setTimer: (fn, milliseconds) => { callback = fn; delay = milliseconds; return { unref() {} } },
|
||
clearTimer: () => {},
|
||
})
|
||
scheduler.start()
|
||
assert.equal(delay, 90_000)
|
||
await callback()
|
||
assert.equal(checks, 1)
|
||
scheduler.configure({ enabled: false, intervalSeconds: 3_600 })
|
||
assert.equal(scheduler.timer, undefined)
|
||
scheduler.configure({ enabled: true, intervalSeconds: 3_600 })
|
||
assert.equal(delay, 3_240_000)
|
||
scheduler.stop()
|
||
})
|
||
|
||
test('scheduler configuration during a running check does not revive an old timer', async () => {
|
||
const timers = []
|
||
let finish
|
||
const scheduler = new UpdateScheduler({
|
||
check: () => new Promise(resolve => { finish = resolve }),
|
||
intervalSeconds: 100,
|
||
setTimer: callback => { const timer = { callback, unref() {} }; timers.push(timer); return timer },
|
||
clearTimer: () => {},
|
||
})
|
||
scheduler.start()
|
||
const running = timers[0].callback()
|
||
scheduler.configure({ enabled: false, intervalSeconds: 3_600 })
|
||
finish()
|
||
await running
|
||
assert.equal(timers.length, 1)
|
||
assert.equal(scheduler.timer, undefined)
|
||
})
|
||
|
||
test('scheduler reports a failed automatic check and continues scheduling', async () => {
|
||
const errors = []
|
||
const timers = []
|
||
const scheduler = new UpdateScheduler({
|
||
check: async () => { throw Object.assign(new Error('metadata offline'), { code: 'ENETDOWN' }) },
|
||
onError: error => { errors.push(error) },
|
||
intervalSeconds: 100,
|
||
setTimer: callback => { const timer = { callback, unref() {} }; timers.push(timer); return timer },
|
||
clearTimer: () => {},
|
||
})
|
||
scheduler.start()
|
||
await timers[0].callback()
|
||
assert.equal(errors[0].code, 'ENETDOWN')
|
||
assert.equal(timers.length, 2)
|
||
scheduler.stop()
|
||
})
|
||
|
||
test('management does not check metadata before the first scheduled interval', async () => {
|
||
const source = await readFile(new URL('../../control-plane/services/management/index.mjs', import.meta.url), 'utf8')
|
||
assert.doesNotMatch(source, /setImmediate\(\(\) => \{ coordinator\.check\(\)\.catch/)
|
||
assert.match(source, /check: \(\) => coordinator\.check\('automatic'\)/)
|
||
assert.match(source, /allowUnavailableMetadata: imageInventory\.authority === 'development'/)
|
||
})
|
||
|
||
test('management exposes authenticated file inventory, search, upload, and ranged download primitives', async () => {
|
||
const root = await mkdtemp(join(tmpdir(), 'dsh-management-files-'))
|
||
const files = join(root, 'files')
|
||
await mkdir(files)
|
||
await writeFile(join(files, 'alpha.txt'), '0123456789')
|
||
const logs = new JsonlLogManager({ root: join(root, 'logs') })
|
||
let server
|
||
const fileTasks = new FileTaskManager({ root: join(root, 'tasks'), onState: state => server?.emit('management-state', { fileTask: state }) })
|
||
await fileTasks.initialize()
|
||
server = createManagementServer({
|
||
coordinator: new Coordinator(), logs,
|
||
fileInventory: new FileInventory(), fileTransfers: new FileTransferManager(), fileTasks, fileEditor: new AtomicFileEditor(),
|
||
fileLocations: { defaultPath: '/custom/workspace', shortcuts: ['/custom/workspace', '/custom/dsh', '/custom/platform', '/'] },
|
||
})
|
||
const socketPath = join(root, 'management.sock')
|
||
await listenManagement(server, socketPath)
|
||
const client = new LocalApiClient(socketPath)
|
||
try {
|
||
assert.deepEqual(await client.request('GET', `${API_PREFIX}files/config`), {
|
||
defaultPath: '/custom/workspace', shortcuts: ['/custom/workspace', '/custom/dsh', '/custom/platform', '/'],
|
||
})
|
||
const encodedRoot = encodeURIComponent(files)
|
||
const listed = await client.request('GET', `${API_PREFIX}files/list?path=${encodedRoot}`)
|
||
assert.deepEqual(listed.entries.map(entry => entry.name), ['alpha.txt'])
|
||
await writeFile(join(files, 'beta.txt'), 'beta')
|
||
const secondPage = await client.request('GET', `${API_PREFIX}files/list?path=${encodedRoot}&limit=1&offset=1`)
|
||
assert.deepEqual(secondPage.entries.map(entry => entry.name), ['beta.txt'])
|
||
assert.equal(await client.request('GET', `${API_PREFIX}files/stat?path=${encodeURIComponent(join(files, 'missing'))}&optional=true`), null)
|
||
const content = await client.request('GET', `${API_PREFIX}files/content?path=${encodeURIComponent(join(files, 'alpha.txt'))}`)
|
||
assert.equal(content.content, '0123456789')
|
||
const saved = await client.request('PUT', `${API_PREFIX}files/content`, {
|
||
path: join(files, 'alpha.txt'), content: 'edited', revision: content.revision,
|
||
})
|
||
assert.equal(saved.size, 6)
|
||
assert.equal(await readFile(join(files, 'alpha.txt'), 'utf8'), 'edited')
|
||
const refreshed = await client.request('GET', `${API_PREFIX}files/list?path=${encodedRoot}`)
|
||
const search = await client.request('POST', `${API_PREFIX}files/tasks`, { operation: 'search', path: files, revision: refreshed.revision, query: 'alpha' })
|
||
await fileTasks.completion(search.taskId)
|
||
assert.equal((await client.request('GET', `${API_PREFIX}files/tasks/${search.taskId}`)).results[0].name, 'alpha.txt')
|
||
|
||
const uploadPath = join(files, 'uploaded.txt')
|
||
const uploaded = await new Promise((resolve, reject) => {
|
||
const request = httpRequest({
|
||
socketPath, method: 'POST',
|
||
path: `${API_PREFIX}files/upload?path=${encodeURIComponent(uploadPath)}&conflict=reject`,
|
||
headers: { 'content-length': '8' },
|
||
}, response => {
|
||
const chunks = []
|
||
response.on('data', chunk => chunks.push(chunk))
|
||
response.on('end', () => resolve({ status: response.statusCode, value: JSON.parse(Buffer.concat(chunks)) }))
|
||
})
|
||
request.once('error', reject)
|
||
request.end('uploaded')
|
||
})
|
||
assert.equal(uploaded.status, 201)
|
||
assert.equal(await readFile(uploadPath, 'utf8'), 'uploaded')
|
||
const duplicate = await new Promise((resolve, reject) => {
|
||
const request = httpRequest({
|
||
socketPath, method: 'POST',
|
||
path: `${API_PREFIX}files/upload?path=${encodeURIComponent(uploadPath)}&conflict=reject`,
|
||
headers: { 'content-length': '9' },
|
||
}, response => {
|
||
const chunks = []
|
||
response.on('data', chunk => chunks.push(chunk))
|
||
response.on('end', () => resolve({ status: response.statusCode, value: JSON.parse(Buffer.concat(chunks)) }))
|
||
})
|
||
request.once('error', reject)
|
||
request.end('duplicate')
|
||
})
|
||
assert.deepEqual(duplicate, { status: 409, value: { error: 'upload target already exists', code: 'FILE_EXISTS' } })
|
||
assert.equal(await readFile(uploadPath, 'utf8'), 'uploaded')
|
||
const downloaded = await new Promise((resolve, reject) => {
|
||
const request = httpRequest({
|
||
socketPath, method: 'GET',
|
||
path: `${API_PREFIX}files/download?path=${encodeURIComponent(uploadPath)}&revision=${encodeURIComponent(uploaded.value.revision)}`,
|
||
headers: { range: 'bytes=2-5' },
|
||
}, response => {
|
||
const chunks = []
|
||
response.on('data', chunk => chunks.push(chunk))
|
||
response.on('end', () => resolve({ status: response.statusCode, body: Buffer.concat(chunks).toString() }))
|
||
})
|
||
request.once('error', reject)
|
||
request.end()
|
||
})
|
||
assert.deepEqual(downloaded, { status: 206, body: 'load' })
|
||
const downloadTask = fileTasks.list().find(task => task.operation === 'download')
|
||
assert.notEqual(downloadTask, undefined)
|
||
await fileTasks.completion(downloadTask.taskId)
|
||
const transferTasks = (await client.request('GET', `${API_PREFIX}files/tasks`)).tasks
|
||
assert.equal(transferTasks.some(task => task.operation === 'upload' && task.status === 'success' && task.processedBytes === 8), true)
|
||
assert.equal(transferTasks.some(task => task.operation === 'upload' && task.status === 'failed' && task.errorCode === 'FILE_EXISTS'), true)
|
||
assert.equal(transferTasks.some(task => task.operation === 'download' && task.status === 'success' && task.processedBytes === 4), true)
|
||
await new Promise(resolve => setTimeout(resolve, 20))
|
||
const audit = await logs.query({ sources: ['audit'] })
|
||
assert.equal(audit.some(entry => entry.message === 'files.upload.completed' && entry.size === 8), true)
|
||
assert.equal(audit.some(entry => entry.message === 'files.download.completed'), true)
|
||
} finally {
|
||
await new Promise(resolve => server.close(resolve))
|
||
}
|
||
})
|