preflite 1.0.1

package/dist/application/task/TaskApplicationService.js

@@ -0,0 +1,378 @@
+import { readFile, rm } from "node:fs/promises";
+import { TaskRecord } from "../../domain/task/TaskRecord.js";
+import { TaskSpec } from "../../domain/task/TaskSpec.js";
+import { EventType, OwnerType, ResourceStatus, TaskStatus } from "../../shared-kernel/enums/index.js";
+import { asResourceId, asTaskId } from "../../shared-kernel/ids/index.js";
+import { LeaseRequiredError } from "../../shared-kernel/errors/index.js";
+import { buildMidsceneReportStemForTask } from "../../utils/midsceneReportConstants.js";
+import path from "node:path";
+import { readMidsceneTaskCacheFileIfExists, seedMidsceneTaskCacheFromRuntimeEnv } from "../../utils/seedMidsceneTaskCache.js";
+const TASK_AUTO_LEASE_TTL_SECONDS = 120;
+function normalizeRuntimeEnv(raw) {
+    if (!raw)
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (!key.startsWith("MIDSCENE_"))
+            continue;
+        const v = String(value ?? "").trim();
+        if (!v)
+            continue;
+        out[key] = v;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+export class TaskApplicationService {
+    taskRepository;
+    resourceRepository;
+    leaseService;
+    sessionService;
+    artifactService;
+    reporter;
+    midsceneRuntime;
+    callbackClient;
+    selfAgentId;
+    taskAgentHttpBaseUrl;
+    taskAgentHttpToken;
+    runningAbortControllers = new Map();
+    resourceExecutionChains = new Map();
+    toTaskFailureMessage(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    async ensureTaskLease(resourceId, taskId) {
+        try {
+            return await this.leaseService.ensureActive(asResourceId(resourceId));
+        }
+        catch (error) {
+            if (!(error instanceof LeaseRequiredError))
+                throw error;
+            const leaseId = `lease-task-${String(taskId)}-${Date.now()}`;
+            console.info(`[TaskApplicationService] auto acquiring lease taskId=${String(taskId)} resourceId=${resourceId} leaseId=${leaseId}`);
+            return this.leaseService.acquire(leaseId, resourceId, String(taskId), OwnerType.PLATFORM_TASK, TASK_AUTO_LEASE_TTL_SECONDS);
+        }
+    }
+    isResourceBusy(resourceId) {
+        return this.resourceExecutionChains.has(resourceId);
+    }
+    async enqueueOnResource(resourceId, run) {
+        const previous = this.resourceExecutionChains.get(resourceId) ?? Promise.resolve();
+        const next = previous
+            .catch(() => { })
+            .then(run)
+            .finally(() => {
+            if (this.resourceExecutionChains.get(resourceId) === next) {
+                this.resourceExecutionChains.delete(resourceId);
+            }
+        });
+        this.resourceExecutionChains.set(resourceId, next);
+        return next;
+    }
+    constructor(taskRepository, resourceRepository, leaseService, sessionService, artifactService, reporter, midsceneRuntime, callbackClient, selfAgentId, 
+    /** 任务子进程内 `installApp`/`uninstallApp` 调本机 Agent HTTP 的根地址（无尾斜杠） */
+    taskAgentHttpBaseUrl, 
+    /** 可选；未设则子进程沿用父进程 `AGENT_HTTP_TOKEN` */
+    taskAgentHttpToken) {
+        this.taskRepository = taskRepository;
+        this.resourceRepository = resourceRepository;
+        this.leaseService = leaseService;
+        this.sessionService = sessionService;
+        this.artifactService = artifactService;
+        this.reporter = reporter;
+        this.midsceneRuntime = midsceneRuntime;
+        this.callbackClient = callbackClient;
+        this.selfAgentId = selfAgentId;
+        this.taskAgentHttpBaseUrl = taskAgentHttpBaseUrl;
+        this.taskAgentHttpToken = taskAgentHttpToken;
+    }
+    buildChildMidsceneEnv(params, spec, taskId) {
+        const base = normalizeRuntimeEnv(params.runtimeEnv) ?? {};
+        const out = { ...base };
+        out.MIDSCENE_FLOW_TASK_ID = String(taskId);
+        out.MIDSCENE_FLOW_REPORT_STEM = buildMidsceneReportStemForTask(spec.requiredPlatform, String(taskId));
+        // 将父进程的 MIDSCENE_* 中未显式传入的自动继承到子进程
+        for (const key of Object.keys(process.env)) {
+            if (key.startsWith("MIDSCENE_") && !(key in out) && process.env[key]?.trim()) {
+                out[key] = process.env[key].trim();
+            }
+        }
+        if (!out.MIDSCENE_OUTPUT_FORMAT?.trim()) {
+            out.MIDSCENE_OUTPUT_FORMAT = "single-html";
+        }
+        return out;
+    }
+    async dispatch(params) {
+        const midsceneKeyCount = Object.keys(normalizeRuntimeEnv(params.runtimeEnv) ?? {}).length;
+        console.info(`[TaskApplicationService] dispatch taskId=${params.taskId} requiredPlatform=${params.requiredPlatform} resourceId=${params.resourceId ?? ""} selector=${JSON.stringify(params.selector ?? null)} scriptLength=${params.script?.length ?? 0} runtimeEnvKeys=${midsceneKeyCount}`);
+        const taskId = asTaskId(params.taskId);
+        const existing = await this.taskRepository.getById(taskId);
+        if (existing) {
+            console.warn(`[TaskApplicationService] skip duplicate dispatch taskId=${params.taskId} existingStatus=${existing.status}`);
+            return;
+        }
+        const scriptKind = params.scriptKind ?? "midscene";
+        const spec = new TaskSpec(params.requiredPlatform, params.script, scriptKind, scriptKind === "airtest" ? {
+            bundleBase64: params.airtestBundleBase64 ?? "",
+            entryDir: params.airtestEntryDir ?? "",
+            archiveName: params.airtestArchiveName,
+            caseRunId: params.caseRunId,
+            caseIndex: params.caseIndex,
+            caseName: params.caseName,
+        } : undefined);
+        const task = new TaskRecord(taskId, spec, TaskStatus.CREATED);
+        await this.taskRepository.save(task);
+        await this.reporter.emit(EventType.TASK_UPDATED, { taskId, status: TaskStatus.CREATED });
+        await this.callbackClient.pushTaskStatus(String(taskId), {
+            agentId: this.selfAgentId,
+            status: TaskStatus.CREATED,
+        }).catch(() => { });
+        const resources = await this.resourceRepository.list();
+        const onlineByPlatform = resources.filter((item) => item.platform === params.requiredPlatform && item.status === ResourceStatus.ONLINE);
+        const requested = params.resourceId?.trim();
+        let candidate = requested != null && requested.length > 0
+            ? onlineByPlatform.find((item) => item.id === requested)
+            : undefined;
+        if (!candidate) {
+            const wantedLabels = (params.selector?.labels ?? []).map((item) => item.trim()).filter(Boolean);
+            const matched = onlineByPlatform.filter((item) => {
+                if (!wantedLabels.length)
+                    return true;
+                const labels = item.capability.labels ?? [];
+                return wantedLabels.every((label) => labels.includes(label));
+            });
+            candidate = matched.find((item) => !this.isResourceBusy(item.id)) ?? matched[0];
+        }
+        if (!candidate) {
+            console.warn(`[TaskApplicationService] no candidate taskId=${params.taskId} requestedResourceId=${requested ?? ""} platform=${params.requiredPlatform}`);
+            task.status = TaskStatus.FAILED;
+            task.message = requested ? `resource not available: ${requested}` : "no online resource matched";
+            await this.taskRepository.save(task);
+            await this.reporter.emit(EventType.TASK_UPDATED, { taskId, status: task.status, message: task.message });
+            return;
+        }
+        const mergedMidsceneEnv = this.buildChildMidsceneEnv(params, spec, taskId);
+        mergedMidsceneEnv.AGENT_RESOURCE_ID = candidate.id;
+        mergedMidsceneEnv.AGENT_HTTP_BASE_URL = this.taskAgentHttpBaseUrl;
+        const qTok = this.taskAgentHttpToken?.trim();
+        if (qTok)
+            mergedMidsceneEnv.AGENT_HTTP_TOKEN = qTok;
+        await this.enqueueOnResource(candidate.id, async () => {
+            try {
+                const lease = await this.ensureTaskLease(candidate.id, taskId);
+                const session = await this.sessionService.createExecution(`exec-${taskId}`, candidate.id, lease.id, String(taskId), OwnerType.PLATFORM_TASK);
+                task.status = TaskStatus.RUNNING;
+                task.sessionId = session.id;
+                await this.taskRepository.save(task);
+                await this.reporter.emit(EventType.TASK_UPDATED, { taskId, status: task.status });
+                await this.callbackClient.pushTaskStatus(String(taskId), {
+                    agentId: this.selfAgentId,
+                    status: task.status,
+                }).catch(() => { });
+                const abortController = new AbortController();
+                this.runningAbortControllers.set(String(taskId), abortController);
+                if (this.midsceneRuntime.prepare) {
+                    await this.midsceneRuntime.prepare(spec, candidate.id, abortController.signal);
+                }
+                seedMidsceneTaskCacheFromRuntimeEnv(mergedMidsceneEnv);
+                let logBuffer = "";
+                let logTimer = null;
+                let anyLogStreamed = false;
+                let logSeq = 0;
+                const LOG_FLUSH_MS = 150;
+                const flushLogBuffer = () => {
+                    if (logTimer) {
+                        clearTimeout(logTimer);
+                        logTimer = null;
+                    }
+                    const chunk = logBuffer;
+                    logBuffer = "";
+                    if (!chunk)
+                        return;
+                    anyLogStreamed = true;
+                    logSeq += 1;
+                    void this.callbackClient
+                        .pushTaskLog(String(taskId), {
+                        agentId: this.selfAgentId,
+                        chunk,
+                        seq: logSeq,
+                        isFinal: false,
+                        stream: "mixed",
+                    })
+                        .catch((err) => {
+                        console.warn(`[TaskApplicationService] pushTaskLog failed taskId=${params.taskId} error=${err instanceof Error ? err.message : String(err)}`);
+                    });
+                };
+                const onReportProgress = (p) => {
+                    void (async () => {
+                        let reportBundleBase64;
+                        let zipPath;
+                        if (p.reportBundleZipUri?.startsWith("file://")) {
+                            zipPath = decodeURIComponent(p.reportBundleZipUri.slice("file://".length));
+                            try {
+                                const buf = await readFile(zipPath);
+                                reportBundleBase64 = buf.toString("base64");
+                            }
+                            catch (err) {
+                                console.warn(`[TaskApplicationService] read report zip failed taskId=${params.taskId} error=${err instanceof Error ? err.message : String(err)}`);
+                            }
+                        }
+                        try {
+                            await this.callbackClient.pushTaskReport(String(taskId), {
+                                agentId: this.selfAgentId,
+                                reportHtml: p.reportHtml ?? "",
+                                reportName: p.reportName,
+                                reportFormat: p.reportFormat,
+                                partial: p.partial,
+                                reportBundleBase64: reportBundleBase64,
+                                ...(p.executionDumpJson !== undefined ? { executionDumpJson: p.executionDumpJson } : {}),
+                                ...(p.executionDumpRevision !== undefined ? { executionDumpRevision: p.executionDumpRevision } : {}),
+                                ...(p.reportAssetFiles !== undefined ? { reportAssetFiles: p.reportAssetFiles } : {}),
+                            });
+                            if (zipPath) {
+                                const zipParent = path.dirname(zipPath);
+                                try {
+                                    await rm(zipPath, { force: true });
+                                    if (path.basename(zipParent).startsWith("report-zip-")) {
+                                        await rm(zipParent, { recursive: true, force: true });
+                                    }
+                                }
+                                catch {
+                                    /* ignore */
+                                }
+                            }
+                        }
+                        catch (err) {
+                            console.warn(`[TaskApplicationService] pushTaskReport failed taskId=${params.taskId} error=${err instanceof Error ? err.message : String(err)}`);
+                        }
+                    })();
+                };
+                const result = await this.midsceneRuntime.execute(spec, candidate.id, abortController.signal, {
+                    runtimeEnv: mergedMidsceneEnv,
+                    taskId: String(taskId),
+                    onLogChunk: (text, stream) => {
+                        logBuffer += stream === "stderr" ? `[stderr] ${text}` : text;
+                        if (logTimer)
+                            return;
+                        logTimer = setTimeout(() => {
+                            logTimer = null;
+                            flushLogBuffer();
+                        }, LOG_FLUSH_MS);
+                    },
+                    onReportProgress,
+                });
+                flushLogBuffer();
+                if (anyLogStreamed) {
+                    logSeq += 1;
+                    void this.callbackClient
+                        .pushTaskLog(String(taskId), {
+                        agentId: this.selfAgentId,
+                        chunk: "",
+                        seq: logSeq,
+                        isFinal: true,
+                        stream: "mixed",
+                    })
+                        .catch((err) => {
+                        console.warn(`[TaskApplicationService] pushTaskLog (final) failed taskId=${params.taskId} error=${err instanceof Error ? err.message : String(err)}`);
+                    });
+                }
+                try {
+                    const cacheAsset = await readMidsceneTaskCacheFileIfExists(mergedMidsceneEnv);
+                    if (cacheAsset) {
+                        await this.callbackClient.pushTaskReport(String(taskId), {
+                            agentId: this.selfAgentId,
+                            reportHtml: "",
+                            partial: true,
+                            executionDumpRevision: 0,
+                            reportAssetFiles: [cacheAsset],
+                        });
+                    }
+                }
+                catch (err) {
+                    console.warn(`[TaskApplicationService] pushTaskReport(cache yaml) failed taskId=${params.taskId} error=${err instanceof Error ? err.message : String(err)}`);
+                }
+                console.info(`[TaskApplicationService] execute finished taskId=${params.taskId} resourceId=${candidate.id} ok=${result.ok} message=${result.message}`);
+                const refs = await this.artifactService.saveTaskArtifacts(taskId, result.artifacts.map((item) => ({ type: item.type, uri: item.uri })));
+                for (const ref of refs) {
+                    await this.reporter.emit(EventType.ARTIFACT_READY, {
+                        taskId,
+                        artifactId: ref.id,
+                        artifactType: ref.type,
+                        uri: ref.uri,
+                    });
+                }
+                const logArtifact = refs.find((item) => item.type === "LOG");
+                if (logArtifact?.uri?.startsWith("file://") && !anyLogStreamed) {
+                    try {
+                        const logPath = decodeURIComponent(logArtifact.uri.slice("file://".length));
+                        const logText = await readFile(logPath, "utf8");
+                        await this.callbackClient.pushTaskLog(String(taskId), {
+                            agentId: this.selfAgentId,
+                            chunk: logText,
+                            seq: 1,
+                            isFinal: true,
+                            stream: "mixed",
+                        });
+                    }
+                    catch (error) {
+                        console.warn(`[TaskApplicationService] callback log (file) failed taskId=${params.taskId} error=${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                if (result.reportInfo?.reportBundleZipPath) {
+                    const zp = result.reportInfo.reportBundleZipPath;
+                    try {
+                        await rm(zp, { force: true });
+                        const parent = path.dirname(zp);
+                        if (path.basename(parent).startsWith("report-zip-")) {
+                            await rm(parent, { recursive: true, force: true });
+                        }
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+                task.status = result.ok ? TaskStatus.SUCCESS : TaskStatus.FAILED;
+                task.message = result.message;
+                await this.taskRepository.save(task);
+                await this.sessionService.closeExecution(session.id);
+                await this.reporter.emit(EventType.TASK_UPDATED, { taskId, status: task.status, message: task.message });
+                await this.callbackClient.pushTaskStatus(String(taskId), {
+                    agentId: this.selfAgentId,
+                    status: task.status,
+                    ...(task.message ? { message: task.message } : {}),
+                }).catch(() => { });
+            }
+            catch (error) {
+                const failureMessage = this.toTaskFailureMessage(error);
+                console.error(`[TaskApplicationService] execute failed taskId=${params.taskId} error=${failureMessage}`);
+                task.status = TaskStatus.FAILED;
+                task.message = failureMessage;
+                await this.taskRepository.save(task);
+                await this.reporter.emit(EventType.TASK_UPDATED, { taskId, status: task.status, message: task.message });
+                await this.callbackClient.pushTaskStatus(String(taskId), {
+                    agentId: this.selfAgentId,
+                    status: task.status,
+                    ...(task.message ? { message: task.message } : {}),
+                }).catch(() => { });
+            }
+            finally {
+                this.runningAbortControllers.delete(String(taskId));
+            }
+        });
+    }
+    async cancel(taskId) {
+        const task = await this.taskRepository.getById(taskId);
+        if (!task)
+            return;
+        const abort = this.runningAbortControllers.get(String(taskId));
+        if (abort)
+            abort.abort("cancelled by platform");
+        task.status = TaskStatus.CANCELLED;
+        task.message = "cancelled by platform";
+        await this.taskRepository.save(task);
+        await this.reporter.emit(EventType.TASK_UPDATED, { taskId, status: task.status, message: task.message });
+        await this.callbackClient.pushTaskStatus(String(taskId), {
+            agentId: this.selfAgentId,
+            status: task.status,
+            message: task.message,
+        }).catch(() => { });
+    }
+}

package/dist/client/agentAppPackageClient.js

@@ -0,0 +1,91 @@
+export class AgentHttpCommandError extends Error {
+    statusCode;
+    body;
+    constructor(message, statusCode, body) {
+        super(message);
+        this.statusCode = statusCode;
+        this.body = body;
+        this.name = "AgentHttpCommandError";
+    }
+}
+function resolveBaseUrl(explicit) {
+    const trimmed = explicit?.trim();
+    if (trimmed)
+        return trimmed.replace(/\/$/, "");
+    const fromTask = process.env.AGENT_HTTP_BASE_URL?.trim();
+    if (fromTask)
+        return fromTask.replace(/\/$/, "");
+    const fromEnv = process.env.AGENT_HTTP_BASE_URL?.trim();
+    if (fromEnv)
+        return fromEnv.replace(/\/$/, "");
+    const port = Number(process.env.AGENT_HTTP_PORT ?? "18998");
+    const p = Number.isFinite(port) && port > 0 ? Math.floor(port) : 18998;
+    return `http://127.0.0.1:${p}`;
+}
+function resolveToken(explicit) {
+    const t = explicit?.trim() ||
+        process.env.AGENT_HTTP_TOKEN?.trim() ||
+        process.env.AGENT_HTTP_TOKEN?.trim();
+    return t || undefined;
+}
+function parseErrorMessage(status, text, body) {
+    if (body && typeof body === "object" && "message" in body) {
+        const m = body.message;
+        if (typeof m === "string" && m.trim())
+            return m;
+    }
+    const slice = text.trim().slice(0, 500);
+    return slice || `HTTP ${status}`;
+}
+async function postInstallOrUninstall(command, opts) {
+    const baseUrl = resolveBaseUrl(opts.baseUrl);
+    const token = resolveToken(opts.token);
+    const url = `${baseUrl}/platform/commands`;
+    const headers = {
+        "Content-Type": "application/json; charset=utf-8",
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const res = await (opts.fetchImpl ?? globalThis.fetch)(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ command }),
+        signal: opts.signal,
+    });
+    const text = await res.text();
+    let body;
+    try {
+        body = text ? JSON.parse(text) : undefined;
+    }
+    catch {
+        body = text;
+    }
+    if (res.ok)
+        return;
+    throw new AgentHttpCommandError(parseErrorMessage(res.status, text, body), res.status, body);
+}
+/**
+ * 经 Agent HTTP 同步安装应用（服务端会等到 adb/ideviceinstaller/hdc 结束再响应）。
+ * 须已占用对应 `resourceId` 的租约（或依赖 Agent 侧自动租约配置）。
+ */
+export async function installAppOnAgent(params) {
+    const { resourceId, appRef, baseUrl, token, signal, fetchImpl } = params;
+    const command = {
+        type: "InstallAppCommand",
+        resourceId,
+        appRef,
+    };
+    await postInstallOrUninstall(command, { baseUrl, token, signal, fetchImpl });
+}
+/**
+ * 经 Agent HTTP 同步卸载应用。
+ */
+export async function uninstallAppOnAgent(params) {
+    const { resourceId, bundleId, baseUrl, token, signal, fetchImpl } = params;
+    const command = {
+        type: "UninstallAppCommand",
+        resourceId,
+        bundleId,
+    };
+    await postInstallOrUninstall(command, { baseUrl, token, signal, fetchImpl });
+}

package/dist/domain/agent/AgentNode.js

@@ -0,0 +1,12 @@
+export class AgentNode {
+    id;
+    capability;
+    online;
+    lastHeartbeatAt;
+    constructor(id, capability, online, lastHeartbeatAt) {
+        this.id = id;
+        this.capability = capability;
+        this.online = online;
+        this.lastHeartbeatAt = lastHeartbeatAt;
+    }
+}

package/dist/domain/agent/AgentRuntime.js

@@ -0,0 +1,6 @@
+export class AgentRuntime {
+    node;
+    constructor(node) {
+        this.node = node;
+    }
+}

package/dist/domain/artifact/ArtifactPipeline.js

@@ -0,0 +1,6 @@
+export class ArtifactPipeline {
+    artifacts;
+    constructor(artifacts) {
+        this.artifacts = artifacts;
+    }
+}

package/dist/domain/artifact/ArtifactRef.js

@@ -0,0 +1,12 @@
+export class ArtifactRef {
+    id;
+    taskId;
+    type;
+    uri;
+    constructor(id, taskId, type, uri) {
+        this.id = id;
+        this.taskId = taskId;
+        this.type = type;
+        this.uri = uri;
+    }
+}

package/dist/domain/event/AgentEvent.js

@@ -0,0 +1,10 @@
+export class AgentEvent {
+    type;
+    timestamp;
+    payload;
+    constructor(type, timestamp, payload) {
+        this.type = type;
+        this.timestamp = timestamp;
+        this.payload = payload;
+    }
+}

package/dist/domain/event/Reporter.js

@@ -0,0 +1,6 @@
+export class Reporter {
+    events;
+    constructor(events) {
+        this.events = events;
+    }
+}

package/dist/domain/health/HealthMetrics.js

@@ -0,0 +1,8 @@
+export class HealthMetrics {
+    healthy;
+    heartbeatCount;
+    constructor(healthy, heartbeatCount) {
+        this.healthy = healthy;
+        this.heartbeatCount = heartbeatCount;
+    }
+}

package/dist/domain/lease/Lease.js

@@ -0,0 +1,28 @@
+import { LeaseStatus } from "../../shared-kernel/enums/index.js";
+export class Lease {
+    id;
+    resourceId;
+    ownerId;
+    ownerType;
+    status;
+    expiresAt;
+    occupantUsername;
+    occupantDisplayName;
+    constructor(id, resourceId, ownerId, ownerType, status, expiresAt, 
+    /** 平台占用者登录名（与 AcquireLeaseCommand.occupantUsername 对齐）；可选兼容旧 Agent */
+    occupantUsername, 
+    /** 平台占用者展示名；可选 */
+    occupantDisplayName) {
+        this.id = id;
+        this.resourceId = resourceId;
+        this.ownerId = ownerId;
+        this.ownerType = ownerType;
+        this.status = status;
+        this.expiresAt = expiresAt;
+        this.occupantUsername = occupantUsername;
+        this.occupantDisplayName = occupantDisplayName;
+    }
+    isActive(now) {
+        return this.status === LeaseStatus.ACTIVE && new Date(this.expiresAt).getTime() > now.getTime();
+    }
+}

package/dist/domain/lease/LeaseManager.js

@@ -0,0 +1,6 @@
+export class LeaseManager {
+    leases;
+    constructor(leases) {
+        this.leases = leases;
+    }
+}

package/dist/domain/repositories/index.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/resource/DeviceDetails.js

@@ -0,0 +1,23 @@
+export function compactDeviceDetails(details) {
+    const out = {};
+    if (details.manufacturer?.trim())
+        out.manufacturer = details.manufacturer.trim();
+    if (details.brand?.trim())
+        out.brand = details.brand.trim();
+    if (details.deviceName?.trim())
+        out.deviceName = details.deviceName.trim();
+    if (details.model?.trim())
+        out.model = details.model.trim();
+    if (details.deviceCodename?.trim())
+        out.deviceCodename = details.deviceCodename.trim();
+    if (details.osName?.trim())
+        out.osName = details.osName.trim();
+    if (details.osVersion?.trim())
+        out.osVersion = details.osVersion.trim();
+    if (details.buildFingerprint?.trim())
+        out.buildFingerprint = details.buildFingerprint.trim();
+    if (details.batteryPercent != null && Number.isFinite(details.batteryPercent)) {
+        out.batteryPercent = Math.max(0, Math.min(100, Math.round(details.batteryPercent)));
+    }
+    return Object.keys(out).length ? out : undefined;
+}

package/dist/domain/resource/DeviceResource.js

@@ -0,0 +1,16 @@
+export class DeviceResource {
+    id;
+    platform;
+    status;
+    capability;
+    deviceDetails;
+    occupancy;
+    constructor(id, platform, status, capability, deviceDetails, occupancy) {
+        this.id = id;
+        this.platform = platform;
+        this.status = status;
+        this.capability = capability;
+        this.deviceDetails = deviceDetails;
+        this.occupancy = occupancy;
+    }
+}

package/dist/domain/resource/ResourceRegistry.js

@@ -0,0 +1,6 @@
+export class ResourceRegistry {
+    resources;
+    constructor(resources) {
+        this.resources = resources;
+    }
+}

package/dist/domain/runtime/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/session/BaseSession.js

@@ -0,0 +1,16 @@
+export class BaseSession {
+    id;
+    resourceId;
+    leaseId;
+    ownerId;
+    ownerType;
+    status;
+    constructor(id, resourceId, leaseId, ownerId, ownerType, status) {
+        this.id = id;
+        this.resourceId = resourceId;
+        this.leaseId = leaseId;
+        this.ownerId = ownerId;
+        this.ownerType = ownerType;
+        this.status = status;
+    }
+}

package/dist/domain/session/DebugSession.js

@@ -0,0 +1,3 @@
+import { BaseSession } from "./BaseSession.js";
+export class DebugSession extends BaseSession {
+}

package/dist/domain/session/ExecutionSession.js

@@ -0,0 +1,3 @@
+import { BaseSession } from "./BaseSession.js";
+export class ExecutionSession extends BaseSession {
+}

package/dist/domain/session/SessionManager.js

@@ -0,0 +1,8 @@
+export class SessionManager {
+    executionSessions;
+    debugSessions;
+    constructor(executionSessions, debugSessions) {
+        this.executionSessions = executionSessions;
+        this.debugSessions = debugSessions;
+    }
+}