@synopackageland/cli 0.14.1 → 0.15.1

package/dist/ctl/transport.js

@@ -0,0 +1,79 @@
+import { strictJson } from './json.js';
+import http from 'node:http';
+import https from 'node:https';
+import { CtlError } from './errors.js';
+export const APP_COOKIE = Symbol("ctlAppCookie");
+export function canonicalOrigin(input, tunnel = false) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        throw new CtlError('CTL_URL_INVALID', 'A NAS origin URL is required.', 'run: synopkgland ctl host add <name> --url https://<nas>:5001');
+    }
+    if (url.username || url.password || url.search || url.hash || url.pathname !== '/' || !(url.protocol === 'https:' || (tunnel && url.protocol === 'http:' && ['127.0.0.1', '[::1]'].includes(url.hostname))))
+        throw new CtlError('CTL_URL_INVALID', 'Use HTTPS, or explicit --ssh-tunnel for a loopback HTTP tunnel.', 'run: synopkgland ctl host add <name> --url https://<nas>:5001');
+    return url.origin;
+}
+export function createRequest(origin, timeoutMs = 10000, ca) {
+    return async (path, body, session) => {
+        if (!path.startsWith('/') || path.startsWith('//') || path.includes('?') || path.includes('#') || path.includes('\\') || path.includes('%') || path.split('/').some(p => p === '.' || p === '..'))
+            throw new CtlError('CTL_PATH_INVALID', 'Unsafe request path.', 'run: synopkgland ctl list --refresh');
+        const url = new URL(path, origin);
+        if (url.origin !== origin || (session && session.origin !== origin))
+            throw new CtlError('CTL_ORIGIN_MISMATCH', 'Credentials cannot cross NAS origins.', 'run: synopkgland ctl host list', 4);
+        const form = body instanceof URLSearchParams;
+        const payload = Buffer.from(form ? body.toString() : JSON.stringify(body));
+        if (payload.length > 1048576)
+            throw new CtlError('CTL_INPUT_TOO_LARGE', 'Request exceeds 1 MiB.', 'Reduce the input.');
+        return new Promise((resolve, reject) => {
+            const headers = { 'content-type': form ? 'application/x-www-form-urlencoded' : 'application/json', accept: 'application/json', 'content-length': String(payload.length), origin };
+            if (session) {
+                headers.cookie = session.cookie;
+                headers['X-SYNO-TOKEN'] = session.token;
+            }
+            const req = (url.protocol === 'https:' ? https : http).request(url, { method: 'POST', headers, timeout: timeoutMs, ...(ca ? { ca } : {}) }, res => {
+                if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+                    res.resume();
+                    reject(new CtlError('CTL_HTTP_ERROR', `HTTP ${res.statusCode}; redirects are never followed.`, 'Check the NAS URL and connection.', 6));
+                    return;
+                }
+                if (!res.headers['content-type']?.includes('application/json')) {
+                    res.resume();
+                    reject(new CtlError('CTL_RESPONSE_INVALID', 'NAS returned non-JSON data.', 'Check the endpoint and installed package.', 5));
+                    return;
+                }
+                const chunks = [];
+                let length = 0;
+                res.on('data', (c) => { length += c.length; if (length > 1048576) {
+                    res.destroy();
+                    reject(new CtlError('CTL_RESPONSE_TOO_LARGE', 'Response exceeds 1 MiB.', 'Use a smaller operation.', 5));
+                }
+                else
+                    chunks.push(c); });
+                res.on('error', () => reject(new CtlError('CTL_NETWORK', 'Response interrupted.', 'Check the NAS connection; state-changing requests are not replayed.', 6)));
+                res.on('end', () => {
+                    try {
+                        const body = strictJson(Buffer.concat(chunks));
+                        if (!form && body?.success === true && body.data && path.startsWith('/webman/3rdparty/') && url.protocol === 'https:') {
+                            const cookies = (res.headers['set-cookie'] ?? []).filter(line => /;\s*Secure(?:;|$)/i.test(line) && /;\s*HttpOnly(?:;|$)/i.test(line) && !/;\s*Domain=/i.test(line));
+                            const own = path.slice(0, path.lastIndexOf('/cgi/')) + '/';
+                            const valid = cookies.filter(line => { const match = /;\s*Path=([^;]+)/i.exec(line); return match?.[1] === own; }).map(line => line.split(';')[0]).filter(pair => !pair.startsWith('id='));
+                            if (valid.length)
+                                Object.defineProperty(body, APP_COOKIE, { value: valid.join('; '), enumerable: false });
+                        }
+                        resolve(body);
+                    }
+                    catch {
+                        reject(new CtlError('CTL_RESPONSE_INVALID', 'Invalid JSON response.', 'Check the installed package.', 5));
+                    }
+                });
+            });
+            const wallTimer = setTimeout(() => req.destroy(), timeoutMs);
+            req.once('close', () => clearTimeout(wallTimer));
+            req.on('timeout', () => req.destroy());
+            req.on('error', () => reject(new CtlError('CTL_NETWORK', 'NAS request failed or timed out.', 'Check the NAS connection and trusted CA; requests are not replayed.', 6)));
+            req.end(payload);
+        });
+    };
+}

package/dist/deploy/deploy.d.ts

@@ -1,8 +1,8 @@
 import type { CommandRunner } from "../standalone/build.js";
-import { type NativeArchFamily } from "../build-spk/dsm-arch.js";
+import type { NativeArchFamily } from "../build-spk/dsm-arch.js";
 import type { ProjectRoot } from "../discovery.js";
 import type { NasHost } from "../host/types.js";
-import { resolveDeploySpkVersion } from "./spk-version.js";
+import type { resolveDeploySpkVersion } from "./spk-version.js";
 export interface DeployProjectOptions {
     project: ProjectRoot;
     /** Gateway architecture. Omitted means "ask the NAS" when needed. */
@@ -27,4 +27,5 @@ export interface DeployProjectResult {
     /** Non-blocking pre-flight remarks, e.g. a read-only Shared Folder grant. */
     notes?: string[];
 }
-export declare function deployProject(options: DeployProjectOptions): Promise<DeployProjectResult>;
+/** Removed legacy dispatch; schema-2 deployment uses planDeployment/deployStandalone. */
+export declare function deployProject(_options: DeployProjectOptions): Promise<DeployProjectResult>;

package/dist/deploy/deploy.js

@@ -1,213 +1,8 @@
-import { buildSpk } from "../build-spk/generator.js";
-import { CONTAINER_ARCH_FAMILIES, isContainerArchFamily } from "../build-spk/dsm-arch.js";
-import { loadContract } from "../contract/load.js";
-import { usesAuthGateway } from "../contract/web-launch.js";
-import { findUnsupportedInstallTypes } from "../contract/unsupported-types.js";
-import { appOriginFromContract } from "../host/open-url.js";
-import { validateProject } from "../validate.js";
-import { resolveDeployIdentity, PACKAGE_IDENTITY_MAX_LENGTH } from "./identity.js";
-import { resolveDeploySpkVersion } from "./spk-version.js";
-import { resolveSharedFolderExtraValues, sharedFolderParameterNames } from "./share-values.js";
-import { resolveDsmUserExtraValues, dsmUserParameterNames } from "./run-as-values.js";
-import { runSharePermissionPreflight } from "./share-permission-preflight.js";
-import { homesParameterNames, resolveHomesExtraValues } from "./homes-values.js";
-import { resolveInstallParameterExtraValues } from "./param-values.js";
-import { loadCompose } from "../compose/analyze.js";
-import { runPortPreflight } from "./port-preflight.js";
-const POSIX_ALL_SHARES_LOOKUP_FAILED = "DEPLOY_POSIX_ALL_SHARES_LOOKUP_FAILED";
-export async function deployProject(options) {
-    const contract = loadContract(options.project.contractPath).contract;
-    // A45/A46: refuse before anything is built or uploaded. validate only warns,
-    // so this is the gate that keeps an uninstallable App off a NAS.
-    const unsupported = findUnsupportedInstallTypes(contract);
-    if (unsupported.length > 0) {
-        const first = unsupported[0];
-        return {
-            ok: false,
-            code: first.code,
-            message: `The Install Parameter "${first.name}" with type: ${first.type} has no usable install path today, ` +
-                "a Package Center install ends in DSM broken/150, so deploy refuses to deploy." +
-                (first.type === "homes"
-                    ? "If you need an administrator-chosen folder, use type: shared_folder."
-                    : "Use type: string, or have the App read the file from ${SYNO_APP_SECRETS_DIR}."),
-        };
-    }
-    const validation = validateProject(options.project);
-    if (!validation.ok) {
-        return { ok: false, code: "VALIDATION_FAILED", message: validation.errors.map((e) => e.code).join(", ") };
-    }
-    const identity = resolveDeployIdentity(options.project, { dev: options.dev });
-    if (identity.packageId.length > PACKAGE_IDENTITY_MAX_LENGTH) {
-        return {
-            ok: false,
-            code: "PACKAGE_IDENTITY_TOO_LONG",
-            message: `The final Package Identity "${identity.packageId}" length ${identity.packageId.length} exceeds the DSM limit of ${PACKAGE_IDENTITY_MAX_LENGTH} characters.`,
-        };
-    }
-    const packageInstalled = await options.host.isPackageInstalled(identity.packageId);
-    const explicitParamNames = new Set(Object.keys(options.paramValues ?? {}));
-    const paramValues = { ...(options.paramValues ?? {}) };
-    const posixAllSharesNames = Object.entries(contract.install ?? {})
-        .filter(([, parameter]) => parameter?.type === "posix_all_shares")
-        .map(([name]) => name);
-    for (const name of posixAllSharesNames) {
-        if (Object.prototype.hasOwnProperty.call(paramValues, name)) {
-            continue;
-        }
-        let shareNames;
-        try {
-            shareNames = await options.host.listShareNames?.();
-        }
-        catch {
-            shareNames = undefined;
-        }
-        const names = (shareNames ?? []).map((value) => value.trim()).filter(Boolean);
-        if (names.length === 0) {
-            return {
-                ok: false,
-                code: POSIX_ALL_SHARES_LOOKUP_FAILED,
-                message: `The Shared Folders of this NAS could not be listed with an administrator session, so the POSIX all-shares parameter "${name}" cannot be filled.`,
-            };
-        }
-        paramValues[name] = names.join(",");
-    }
-    const paramResolved = resolveInstallParameterExtraValues({
-        contract,
-        provided: paramValues,
-    });
-    if (!paramResolved.ok) {
-        return { ok: false, code: paramResolved.code, message: paramResolved.message };
-    }
-    const homesResolved = await resolveHomesExtraValues({
-        requiredKeys: homesParameterNames(contract),
-        lookup: async () => options.host.resolveHomesPath?.(),
-    });
-    if (!homesResolved.ok) {
-        return { ok: false, code: homesResolved.code, message: homesResolved.message };
-    }
-    const shareResolved = await resolveSharedFolderExtraValues({
-        requiredKeys: sharedFolderParameterNames(contract).filter((key) => !packageInstalled || options.shareValues?.[key] !== undefined),
-        provided: options.shareValues ?? {},
-        lookup: async (logicalName) => options.host.resolveSharePath?.(logicalName),
-    });
-    if (!shareResolved.ok) {
-        return { ok: false, code: shareResolved.code, message: shareResolved.message };
-    }
-    const runAsResolved = resolveDsmUserExtraValues({
-        requiredKeys: dsmUserParameterNames(contract).filter((key) => !packageInstalled || options.runAsValues?.[key] !== undefined),
-        provided: options.runAsValues ?? {},
-    });
-    if (!runAsResolved.ok) {
-        return { ok: false, code: runAsResolved.code, message: runAsResolved.message };
-    }
-    // A42 pre-flight: preinst runs as the package user and can never read ACL, so
-    // the only place that can catch "selected user cannot reach selected Share" is
-    // here, where we still hold an administrator session. Refuses before install.
-    const sharePermission = await runSharePermissionPreflight({
-        shares: Object.fromEntries(sharedFolderParameterNames(contract)
-            .map((key) => [key, (options.shareValues ?? {})[key] ?? ""])
-            .filter(([, value]) => value.trim() !== "")),
-        runAsUsers: runAsResolved.extraValues,
-        listSharePermissions: options.host.listSharePermissions
-            ? (name) => options.host.listSharePermissions(name)
-            : undefined,
-        listUserGroups: options.host.listUserGroups
-            ? (name) => options.host.listUserGroups(name)
-            : undefined,
-    });
-    if (!sharePermission.ok) {
-        return { ok: false, code: sharePermission.code, message: sharePermission.message };
-    }
-    const portPreflight = await runPortPreflight({
-        compose: loadCompose(options.project.composePath)?.compose,
-        packageIdentity: identity.packageId,
-        listPortInfo: options.host.listPortInfo
-            ? () => options.host.listPortInfo()
-            : undefined,
-    });
-    if (!portPreflight.ok) {
-        return { ok: false, code: portPreflight.code, message: portPreflight.message };
-    }
-    const extraValues = {
-        ...paramResolved.extraValues,
-        ...homesResolved.extraValues,
-        ...shareResolved.extraValues,
-        ...runAsResolved.extraValues,
-    };
-    // The upgrade wizard deliberately ignores auto-filled Share and Run-as controls unless
-    // the administrator opted into a change. Keep the CLI's explicit upgrade
-    // flags equivalent to checking those controls.
-    if (packageInstalled) {
-        for (const name of sharedFolderParameterNames(contract)) {
-            if ((options.shareValues?.[name] ?? "").trim() !== "") {
-                extraValues[`CHANGE_${name}`] = "true";
-            }
-        }
-        for (const name of dsmUserParameterNames(contract)) {
-            if ((options.runAsValues?.[name] ?? "").trim() !== "") {
-                extraValues[`CHANGE_${name}`] = "true";
-            }
-        }
-        for (const name of posixAllSharesNames) {
-            if (explicitParamNames.has(name) && (paramValues[name] ?? "").trim() !== "") {
-                extraValues[`CHANGE_${name}`] = "true";
-            }
-        }
-    }
-    const resolveSpkVersion = options.spkVersionResolver ?? resolveDeploySpkVersion;
-    let spkVersion;
-    try {
-        spkVersion = await resolveSpkVersion(options.project, options.host, identity.packageId);
-    }
-    catch (error) {
-        return { ok: false, code: "DEPLOY_VERSION_INVALID",
-            message: error instanceof Error ? error.message : String(error) };
-    }
-    let archFamily = options.archFamily;
-    // A DSM-authenticated web App ships a native gateway CGI, so it is built per architecture too.
-    if (archFamily === undefined && usesAuthGateway(contract)) {
-        archFamily = await options.host.getArchFamily?.();
-        if (archFamily === undefined) {
-            return {
-                ok: false,
-                code: "NATIVE_ARCH_UNDETERMINED",
-                message: "The CPU architecture could not be determined from this NAS. Specify --arch x86_64 or --arch aarch64 explicitly.",
-            };
-        }
-    }
-    if (archFamily !== undefined && !isContainerArchFamily(archFamily)) {
-        return {
-            ok: false,
-            code: "CONTAINER_ARCH_UNSUPPORTED",
-            message: `Container Manager Apps support only ${CONTAINER_ARCH_FAMILIES.join(", ")}; DSM does not provide Container Manager for ${archFamily}.`,
-        };
-    }
-    const build = await buildSpk({
-        project: options.project,
-        packageIdentity: identity.packageId,
-        displayname: identity.displayname,
-        spkVersion,
-        archFamily,
-        gatewayRun: options.gatewayRun,
-    });
-    if (!build.ok || !build.outputPath) {
-        return { ok: false, code: "BUILD_SPK_FAILED", message: build.errors.join(", ") };
-    }
-    try {
-        await options.host.installFromLocalSpk({
-            packageId: identity.packageId,
-            version: spkVersion,
-            spkPath: build.outputPath,
-            extraValues,
-        });
-    }
-    catch (error) {
-        return { ok: false, code: "LOCAL_SPK_INSTALL_FAILED",
-            message: error instanceof Error ? error.message : String(error) };
-    }
+/** Removed legacy dispatch; schema-2 deployment uses planDeployment/deployStandalone. */
+export async function deployProject(_options) {
     return {
-        ok: true, packageId: identity.packageId, spkPath: build.outputPath,
-        openUrl: appOriginFromContract(options.host.dsmOrigin, contract),
-        version: spkVersion, notes: sharePermission.notes,
+        ok: false,
+        code: "COMPOSE_LEGACY_MANIFEST_REMOVED",
+        message: "Use schema-2 dsm-package.yaml and the unified deployment plan; the legacy Compose installer is removed.",
     };
 }

package/dist/deploy/plan.js

@@ -3,7 +3,7 @@ import { loadContract } from "../contract/load.js";
 import { validateProject } from "../validate.js";
 import { findStandaloneRoot, loadStandaloneManifest, } from "../standalone/manifest.js";
 import { buildStandalone } from "../standalone/build.js";
-import { buildNativeLayout, isNativeLayout, loadNativeLayout } from "../standalone/native-layout.js";
+import { buildNativeLayout, isNativeLayout, loadNativeLayout, } from "../standalone/native-layout.js";
 import { resolveDeployIdentity } from "./identity.js";
 import { nextDeployVersion } from "./spk-version.js";
 import { resolveNativeInstallValues } from "./native-install-values.js";
@@ -29,17 +29,28 @@ export function planDeployment(root, options = {}) {
             throw fail("STANDALONE_ARCH_NOT_DECLARED", `Architecture not declared: ${options.arch}; add it to dsm-package.yaml arches to deploy it`);
         return {
             root: standalone,
-            kind: m.backend.kind === "binary" ? "binary" : `native-${m.backend.kind}`,
+            kind: m.compose
+                ? "container"
+                : m.backend.kind === "binary"
+                    ? "binary"
+                    : `native-${m.backend.kind}`,
             packageId: m.package,
             version: m.spkVersion,
             arch: options.arch,
             capabilities: Object.keys(m.capabilities),
             transport: "dsm-local-spk",
-            notes: m.capabilities.rootOps || m.capabilities.delegate || m.capabilities.webapi
+            notes: m.compose
                 ? [
-                    "Installation does not mean ready. Approve boot and control tasks once in the App window. An executor-only upgrade stays ready without approval (INFO anchors the executor digest); a policy digest change requires approval again.",
+                    "Containers use the fixed package identity; they do not inherit signed-in File Station ACLs.",
+                    ...m.compose.plan.acceptance_blockers,
                 ]
-                : [],
+                : m.capabilities.rootOps ||
+                    m.capabilities.delegate ||
+                    m.capabilities.webapi
+                    ? [
+                        "Installation does not mean ready. Approve boot and control tasks once in the App window. An executor-only upgrade stays ready without approval (INFO anchors the executor digest); a policy digest change requires approval again.",
+                    ]
+                    : [],
         };
     }
     const project = findProjectRoot(root);
@@ -100,7 +111,11 @@ async function buildForDeploy(plan, arch, installed, options) {
         const name = Object.keys(options.params ?? {})[0];
         if (name)
             throw fail("DEPLOY_PARAM_UNDECLARED", `${m.package} has no install wizard values; remove --param ${name}.`);
-        const { outputs } = await buildNativeLayout({ root: plan.root, arches: [layoutArch], run: options.run });
+        const { outputs } = await buildNativeLayout({
+            root: plan.root,
+            arches: [layoutArch],
+            run: options.run,
+        });
         return { outputs, extraValues: {} };
     }
     const loaded = loadStandaloneManifest(plan.root);
@@ -109,7 +124,11 @@ async function buildForDeploy(plan, arch, installed, options) {
     const values = resolveNativeInstallValues(loaded.manifest, options.params ?? {}, { installed });
     if (!values.ok)
         throw fail(values.code, values.message);
-    const { outputs } = await buildStandalone({ root: plan.root, arches: [arch], run: options.run });
+    const { outputs } = await buildStandalone({
+        root: plan.root,
+        arches: [arch],
+        run: options.run,
+    });
     return { outputs, extraValues: values.extraValues };
 }
 export async function deployStandalone(plan, host, options = {}) {

package/dist/dev.js

@@ -1,9 +1,6 @@
-import { existsSync } from "node:fs";
 import { createDockerComposeRunner } from "./compose/runner.js";
 /** Run the application's own Compose project locally. */
 export async function runDev(options) {
-    if (!existsSync(options.project.composePath))
-        throw new Error('dev requires compose.yaml');
     const runner = options.composeRunner ?? createDockerComposeRunner();
     try {
         await runner.up(options.project.root);
@@ -13,5 +10,9 @@ export async function runDev(options) {
         await runner.down?.(options.project.root);
         throw error;
     }
-    return { close: async () => { await runner.down?.(options.project.root); } };
+    return {
+        close: async () => {
+            await runner.down?.(options.project.root);
+        },
+    };
 }

package/dist/e2e/dsm.d.ts

@@ -17,7 +17,7 @@ type Page = ReturnType<NonNullable<ReturnType<typeof surfaceOf>>["page"]>;
 type Locator = ReturnType<Page["locator"]>;
 /** The DSM URL the browser opens: DSM_E2E_URL, else the local end of the SSH tunnel. */
 export declare function dsmUrl(env?: Env): string;
-/** ssh arguments forwarding the loopback ports of `forwards` to the NAS. */
+/** ssh arguments forwarding loopback ports to the NAS; DSM_E2E_SSH is required. */
 export declare function tunnelArgs(env?: Env): string[];
 /** A loopback port nothing listens on now, for a tunnel that names none. */
 export declare function freePort(): Promise<number>;
@@ -122,7 +122,7 @@ export declare function waitForDesktop(page?: Page): Promise<void>;
 /**
  * Closes every DSM notification card; returns how many were closed. DSM shows
  * them a moment after the desktop (the admin's "Admin account security" card
- * about 2 s later on vt-nas), so it first waits up to
+ * about 2 s later on a DSM 7.4 test NAS), so it first waits up to
  * DSM_E2E_NOTIFICATION_WAIT_MS (default 5000) for one.
  */
 export declare function dismissNotifications(page?: Page, env?: Env): Promise<number>;

package/dist/e2e/dsm.js

@@ -41,11 +41,14 @@ function forwards(env) {
         ...extra(env.DSM_E2E_TUNNEL_HTTPS_PORT, env.DSM_E2E_REMOTE_HTTPS_PORT, "443"),
     ];
 }
-/** ssh arguments forwarding the loopback ports of `forwards` to the NAS. */
+/** ssh arguments forwarding loopback ports to the NAS; DSM_E2E_SSH is required. */
 export function tunnelArgs(env = process.env) {
+    const target = env.DSM_E2E_SSH?.trim();
+    if (!target)
+        throw new Error("DSM_E2E_SSH is required to open a NAS tunnel; set it to user@nas.example (using your NAS host).");
     return ["-N", "-o", "BatchMode=yes", "-o", "ExitOnForwardFailure=yes",
         ...forwards(env).flatMap(([local, remote]) => ["-L", `127.0.0.1:${local}:127.0.0.1:${remote}`]),
-        env.DSM_E2E_SSH || "root@vt-nas.syno"];
+        target];
 }
 /** A loopback port nothing listens on now, for a tunnel that names none. */
 export function freePort() {
@@ -80,12 +83,13 @@ export async function runWithTunnel(command, outer = process.env) {
         throw new Error("runWithTunnel needs a command to run.");
     const port = Number(outer.DSM_E2E_TUNNEL_PORT || await freePort());
     const env = { ...outer, DSM_E2E_TUNNEL_PORT: String(port) };
+    const args = tunnelArgs(env);
     const ports = forwards(env).map(([local]) => Number(local));
     for (const used of ports) {
         if (await portOpen(used))
             throw new Error(`Port ${used} is already in use; name another DSM_E2E_TUNNEL_* port or close it before opening the tunnel.`);
     }
-    const ssh = spawn(env.DSM_E2E_SSH_BIN || "ssh", tunnelArgs(env), { stdio: ["ignore", "ignore", "inherit"] });
+    const ssh = spawn(env.DSM_E2E_SSH_BIN || "ssh", args, { stdio: ["ignore", "ignore", "inherit"] });
     let sshExited = false;
     ssh.once("exit", () => { sshExited = true; });
     try {
@@ -93,7 +97,7 @@ export async function runWithTunnel(command, outer = process.env) {
         for (const waiting of ports) {
             while (!(await portOpen(waiting))) {
                 if (sshExited || Date.now() > deadline)
-                    throw new Error(`The SSH tunnel to ${tunnelArgs(env).at(-1)} did not open on port ${waiting}.`);
+                    throw new Error(`The SSH tunnel to ${args.at(-1)} did not open on port ${waiting}.`);
                 await new Promise(accept => setTimeout(accept, 100));
             }
         }
@@ -364,7 +368,7 @@ const notificationCloseSelector = ".v-notification-container .v-notification-pan
 /**
  * Closes every DSM notification card; returns how many were closed. DSM shows
  * them a moment after the desktop (the admin's "Admin account security" card
- * about 2 s later on vt-nas), so it first waits up to
+ * about 2 s later on a DSM 7.4 test NAS), so it first waits up to
  * DSM_E2E_NOTIFICATION_WAIT_MS (default 5000) for one.
  */
 export async function dismissNotifications(page = dsmPage(), env = process.env) {
@@ -454,7 +458,7 @@ async function restoredSessionLive(page) {
  */
 export async function signIn(app, user = "admin", env = process.env) {
     const url = dsmUrl(env);
-    const file = profilePath(env.DSM_E2E_TARGET || "vt-nas", user, env);
+    const file = profilePath(env.DSM_E2E_TARGET || "dsm", user, env);
     const context = surface().context();
     const profile = loadProfile(file, url);
     if (profile)