@synopackageland/cli 0.1.0

package/dist/host/dsm-client.js

@@ -0,0 +1,290 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { IDENTITY_CGI_PATH } from "./broker-paths.js";
+import { packageSourceOrigin } from "../deploy/catalog-publish.js";
+import { lookupSharePathWithSynoagentcli } from "./share-lookup.js";
+import { dsmFetch } from "./dsm-http.js";
+import { installPackageFromCatalog, installPackageFromLocalSpk, fetchInstalledPackageState } from "./catalog-install.js";
+import { resolveHostCredentials } from "./credentials.js";
+export function createNasHost(options = {}) {
+    const credentials = options.credentials ?? resolveHostCredentials(options.host);
+    if (!credentials) {
+        return null;
+    }
+    return createDsmNasHost(credentials, options.host);
+}
+function synoagentcli(args, profileName) {
+    const fullArgs = [...args];
+    if (profileName) {
+        fullArgs.push("--host", profileName);
+    }
+    const result = spawnSync("synoagentcli", fullArgs, { encoding: "utf8" });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+    };
+}
+function createDsmNasHost(credentials, profileName) {
+    const dsmOrigin = credentials.dsmOrigin.replace(/\/$/, "");
+    const brokerBaseUrl = `${dsmOrigin}${IDENTITY_CGI_PATH}`;
+    let cookieHeader = credentials.cookieHeader;
+    const projectEnvCache = new Map();
+    const ensureLogin = async () => {
+        if (cookieHeader) {
+            return;
+        }
+        const query = new URLSearchParams({
+            api: "SYNO.API.Auth",
+            version: "3",
+            method: "login",
+            account: credentials.username,
+            passwd: credentials.password,
+            session: "FileStation",
+            format: "cookie",
+        });
+        const response = await dsmFetch(`${dsmOrigin}/webapi/entry.cgi?${query.toString()}`);
+        const setCookie = typeof response.headers.getSetCookie === "function"
+            ? response.headers.getSetCookie()
+            : response.headers.get("set-cookie")
+                ? [response.headers.get("set-cookie")]
+                : [];
+        const pairs = setCookie
+            .map((line) => line.split(";")[0]?.trim())
+            .filter((pair) => Boolean(pair));
+        cookieHeader = pairs.join("; ");
+    };
+    const ensureInnerLoopApi = async () => {
+        await ensureLogin();
+        const response = await dsmFetch(`${brokerBaseUrl}/api/v1/inner-loop/diagnostics?package=probe`, { headers: { cookie: cookieHeader ?? "" } });
+        const text = await response.text();
+        if (response.status === 404 || text.trimStart().startsWith("<")) {
+            const error = new Error("Broker inner-loop API 不可用（收到 HTML 404）。請將 SynoPkgLandService 升級到 >=0.1.0-0016。");
+            error.code = "INNER_LOOP_API_MISSING";
+            throw error;
+        }
+        try {
+            JSON.parse(text);
+        }
+        catch {
+            const error = new Error("Broker inner-loop API 回傳非 JSON 內容。");
+            error.code = "INNER_LOOP_API_MISSING";
+            throw error;
+        }
+    };
+    const ensurePackageSourceFeed = (origin) => {
+        const feed = origin.replace(/\/$/, "") + "/";
+        const list = synoagentcli(["dsm", "package-center", "source", "list"], profileName);
+        if (list.status !== 0) {
+            return;
+        }
+        const parsed = JSON.parse(list.stdout);
+        const items = parsed.data?.items ?? [];
+        const normalizedFeed = feed.replace(/\/$/, "");
+        const existing = items.find((item) => item.feed?.replace(/\/$/, "") === normalizedFeed);
+        if (existing) {
+            return;
+        }
+        const stale = items.find((item) => item.name === "package-land-throwaway");
+        const payload = { name: "package-land-throwaway", feed };
+        const staging = mkdtempSync(join(tmpdir(), "syno-package-source-feed-"));
+        const jsonPath = join(staging, "source.json");
+        writeFileSync(jsonPath, JSON.stringify(payload));
+        try {
+            if (stale?.feed) {
+                synoagentcli(["dsm", "package-center", "source", "update", stale.feed, "--json-file", jsonPath], profileName);
+                return;
+            }
+            synoagentcli(["dsm", "package-center", "source", "add", "--json-file", jsonPath], profileName);
+        }
+        finally {
+            rmSync(staging, { recursive: true, force: true });
+        }
+    };
+    return {
+        dsmOrigin,
+        installationId: "live-nas",
+        async requestAttestation(input) {
+            await ensureInnerLoopApi();
+            await ensureLogin();
+            const response = await dsmFetch(`${brokerBaseUrl}/api/v1/inner-loop/attest`, {
+                method: "POST",
+                headers: {
+                    cookie: cookieHeader ?? "",
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify(input),
+            });
+            const text = await response.text();
+            let body;
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                const error = new Error("Broker inner-loop attest 回傳非 JSON 內容。");
+                error.code = "INNER_LOOP_API_MISSING";
+                throw error;
+            }
+            if (!response.ok) {
+                const error = new Error(body.error?.message ?? `Attestation failed (${response.status})`);
+                error.code = body.error?.code;
+                throw error;
+            }
+            return { kind: "local", attestationDigest: body.attestationDigest ?? "" };
+        },
+        async ensurePackageSource(origin) {
+            ensurePackageSourceFeed(origin);
+        },
+        async installFromCatalog(input) {
+            try {
+                ensurePackageSourceFeed(packageSourceOrigin());
+                await ensureLogin();
+                await installPackageFromCatalog({
+                    dsmOrigin,
+                    cookieHeader: cookieHeader ?? "",
+                    packageId: input.packageId,
+                    profileName,
+                    expectedVersion: input.version,
+                    packageSourceOrigin: packageSourceOrigin(),
+                    extraValues: input.extraValues,
+                });
+            }
+            finally {
+                projectEnvCache.delete(input.packageId);
+            }
+        },
+        async installFromLocalSpk(input) {
+            try {
+                await ensureLogin();
+                await installPackageFromLocalSpk({
+                    dsmOrigin,
+                    cookieHeader: cookieHeader ?? "",
+                    packageId: input.packageId,
+                    spkPath: input.spkPath,
+                    version: input.version,
+                    profileName,
+                    extraValues: input.extraValues,
+                });
+            }
+            finally {
+                projectEnvCache.delete(input.packageId);
+            }
+        },
+        async resolveSharePath(logicalName) {
+            return lookupSharePathWithSynoagentcli(logicalName, profileName);
+        },
+        async getInstalledProjectEnv(packageIdentity) {
+            const cached = projectEnvCache.get(packageIdentity);
+            if (cached) {
+                return cached;
+            }
+            const lookup = (async () => {
+                await ensureLogin();
+                const response = await dsmFetch(`${brokerBaseUrl}/api/v1/inner-loop/project-env/${encodeURIComponent(packageIdentity)}`, { headers: { cookie: cookieHeader ?? "" } });
+                if (response.ok) {
+                    const payload = (await response.json());
+                    if (!payload.env || typeof payload.env !== "object" || Array.isArray(payload.env)) {
+                        return undefined;
+                    }
+                    return Object.fromEntries(Object.entries(payload.env).filter((entry) => typeof entry[1] === "string"));
+                }
+                return undefined;
+            })();
+            projectEnvCache.set(packageIdentity, lookup);
+            return lookup;
+        },
+        async getAttestationInfo(packageIdentity) {
+            await ensureLogin();
+            const response = await dsmFetch(`${brokerBaseUrl}/api/v1/inner-loop/info/${encodeURIComponent(packageIdentity)}`, { headers: { cookie: cookieHeader ?? "" } });
+            const text = await response.text();
+            if (response.status === 404 || text.trimStart().startsWith("<")) {
+                const error = new Error("Broker inner-loop info 不可用（HTML 404）。");
+                error.code = "INNER_LOOP_API_MISSING";
+                throw error;
+            }
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                const error = new Error("Broker inner-loop info 回傳非 JSON 內容。");
+                error.code = "INNER_LOOP_API_MISSING";
+                throw error;
+            }
+        },
+        async getInstalledPackageVersion(packageIdentity) {
+            await ensureLogin();
+            const viaDsm = await fetchInstalledPackageState(dsmOrigin, cookieHeader ?? "", packageIdentity);
+            if (viaDsm?.version) {
+                return viaDsm.version;
+            }
+            const result = synoagentcli(["dsm", "package-center", "get", packageIdentity], profileName);
+            if (result.status !== 0) {
+                return undefined;
+            }
+            try {
+                const parsed = JSON.parse(result.stdout);
+                return parsed.data?.version;
+            }
+            catch {
+                return undefined;
+            }
+        },
+        async isPackageInstalled(packageIdentity) {
+            await ensureLogin();
+            const viaDsm = await fetchInstalledPackageState(dsmOrigin, cookieHeader ?? "", packageIdentity);
+            if (viaDsm) {
+                return viaDsm.installed;
+            }
+            const result = synoagentcli(["dsm", "package-center", "get", packageIdentity], profileName);
+            return result.status === 0;
+        },
+        async fetchContainerLogs(packageIdentity) {
+            const result = synoagentcli(["dsm", "package-center", "status", packageIdentity], profileName);
+            if (result.status !== 0) {
+                return [];
+            }
+            return result.stdout
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .map((line) => `[status] ${line}`);
+        },
+        async smokeRequireLogin(input) {
+            await ensureLogin();
+            const info = await this.getAttestationInfo(input.packageIdentity);
+            let openUrl = info.openUrl;
+            if (!openUrl) {
+                const pkg = synoagentcli(["dsm", "package-center", "get", input.packageIdentity], profileName);
+                if (pkg.status === 0) {
+                    try {
+                        const parsed = JSON.parse(pkg.stdout);
+                        openUrl = parsed.data?.url?.[0];
+                    }
+                    catch {
+                        // ignore parse errors
+                    }
+                }
+            }
+            if (!openUrl) {
+                return { ok: false };
+            }
+            const origin = new URL(openUrl).origin;
+            const response = await dsmFetch(`${brokerBaseUrl}/api/v1/auth/login`, {
+                method: "POST",
+                headers: {
+                    cookie: cookieHeader ?? input.cookieHeader,
+                    origin,
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({ packageId: input.packageIdentity }),
+            });
+            if (!response.ok) {
+                return { ok: false };
+            }
+            const body = (await response.json());
+            return { ok: Boolean(body.user?.username), username: body.user?.username };
+        },
+    };
+}

package/dist/host/dsm-http.d.ts

@@ -0,0 +1 @@
+export declare function dsmFetch(url: string, init?: RequestInit): Promise<Response>;

package/dist/host/dsm-http.js

@@ -0,0 +1,87 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function isHostUnreachable(error) {
+    const code = error.cause?.code
+        ?? error.code;
+    return code === "EHOSTUNREACH" || code === "ENETUNREACH";
+}
+function headerRecord(headers) {
+    if (!headers) {
+        return {};
+    }
+    if (headers instanceof Headers) {
+        return Object.fromEntries(headers.entries());
+    }
+    if (Array.isArray(headers)) {
+        return Object.fromEntries(headers);
+    }
+    return { ...headers };
+}
+export async function dsmFetch(url, init = {}) {
+    try {
+        return await fetch(url, init);
+    }
+    catch (error) {
+        if (!isHostUnreachable(error)) {
+            throw error;
+        }
+        return curlFetch(url, init);
+    }
+}
+async function curlFetch(url, init) {
+    const staging = mkdtempSync(join(tmpdir(), "synopkgland-dsm-http-"));
+    const headerFile = join(staging, "headers");
+    const bodyFile = join(staging, "body");
+    try {
+        const args = ["-sS", "-D", headerFile, "-o", bodyFile, "-w", "%{http_code}", "-X", init.method ?? "GET"];
+        const headers = headerRecord(init.headers);
+        for (const [name, value] of Object.entries(headers)) {
+            if (name.toLowerCase() === "content-type" && init.body instanceof FormData) {
+                continue;
+            }
+            args.push("-H", `${name}: ${value}`);
+        }
+        let stdin;
+        if (init.body instanceof FormData) {
+            for (const [name, value] of init.body.entries()) {
+                if (typeof value === "string") {
+                    args.push("-F", `${name}=${value}`);
+                    continue;
+                }
+                const filename = "name" in value && typeof value.name === "string" ? value.name : "upload.bin";
+                const partPath = join(staging, filename);
+                writeFileSync(partPath, Buffer.from(await value.arrayBuffer()));
+                args.push("-F", `${name}=@${partPath};filename=${filename}`);
+            }
+        }
+        else if (typeof init.body === "string") {
+            stdin = Buffer.from(init.body);
+            args.push("--data-binary", "@-");
+        }
+        else if (init.body) {
+            stdin = Buffer.from(await new Response(init.body).arrayBuffer());
+            args.push("--data-binary", "@-");
+        }
+        args.push(url);
+        const result = spawnSync("curl", args, { encoding: "utf8", input: stdin });
+        if (result.status !== 0) {
+            throw new Error(result.stderr || `curl exit ${result.status}`);
+        }
+        const status = Number((result.stdout ?? "").trim().slice(-3));
+        const rawHeaders = readFileSync(headerFile, "utf8");
+        const body = readFileSync(bodyFile);
+        const responseHeaders = new Headers();
+        for (const line of rawHeaders.split(/\r?\n/)) {
+            const idx = line.indexOf(":");
+            if (idx > 0) {
+                responseHeaders.append(line.slice(0, idx).trim(), line.slice(idx + 1).trim());
+            }
+        }
+        return new Response(body, { status: Number.isInteger(status) ? status : 502, headers: responseHeaders });
+    }
+    finally {
+        rmSync(staging, { recursive: true, force: true });
+    }
+}

package/dist/host/fake-nas.d.ts

@@ -0,0 +1,16 @@
+import type { AttestationKind, HostInstallRecord, NasHost } from "./types.js";
+export interface FakeNasHostOptions {
+    curated?: string[];
+    dsmOrigin?: string;
+    installationId?: string;
+    shares?: Record<string, string>;
+    installedEnv?: Record<string, Record<string, string>>;
+}
+export declare function createFakeNasHost(options?: FakeNasHostOptions): NasHost & {
+    installs: HostInstallRecord[];
+    attestations: Set<string>;
+    attestationInfo(packageIdentity: string): {
+        attestationKind: AttestationKind;
+    } | undefined;
+    seedInstalled(packageIdentity: string): void;
+};

package/dist/host/fake-nas.js

@@ -0,0 +1,116 @@
+import { webStationAlias } from "../contract/web-launch.js";
+export function createFakeNasHost(options = {}) {
+    const dsmOrigin = options.dsmOrigin ?? "http://nas.example:5000";
+    const installationId = options.installationId ?? "fake-installation";
+    const curated = new Set(options.curated ?? []);
+    const installs = [];
+    const localAttestations = new Map();
+    const installed = new Set();
+    const openUrls = new Map();
+    const shares = { ...(options.shares ?? {}) };
+    const installedEnv = Object.fromEntries(Object.entries(options.installedEnv ?? {}).map(([packageId, env]) => [packageId, { ...env }]));
+    const host = {
+        dsmOrigin,
+        installationId,
+        installs,
+        attestations: new Set(),
+        markCurated(packageIdentity) {
+            curated.add(packageIdentity);
+            localAttestations.set(packageIdentity, "app-package");
+        },
+        seedInstalled(packageIdentity) {
+            installed.add(packageIdentity);
+        },
+        async resolveSharePath(logicalName) {
+            return shares[logicalName];
+        },
+        async getInstalledProjectEnv(packageIdentity) {
+            const env = installedEnv[packageIdentity];
+            return env ? { ...env } : undefined;
+        },
+        attestationInfo(packageIdentity) {
+            const kind = localAttestations.get(packageIdentity) ?? (installed.has(packageIdentity) ? "local" : "none");
+            return kind === "none" ? undefined : { attestationKind: kind };
+        },
+        async requestAttestation(input) {
+            if (curated.has(input.packageIdentity) && !input.allowCuratedDowngrade) {
+                const error = new Error("Curated deploy refused");
+                error.code = "CURATED_DEPLOY_REFUSED";
+                throw error;
+            }
+            if (curated.has(input.packageIdentity) && input.allowCuratedDowngrade) {
+                localAttestations.set(input.packageIdentity, "local");
+            }
+            else {
+                localAttestations.set(input.packageIdentity, "local");
+            }
+            const digest = `${input.packageIdentity}:${input.bundleDigest}:${input.contractDigest}`;
+            host.attestations.add(input.packageIdentity);
+            return { kind: "local", attestationDigest: digest };
+        },
+        async ensurePackageSource() { },
+        async installFromCatalog(input) {
+            installs.push({
+                packageId: input.packageId,
+                version: input.version,
+                source: "package-center",
+                extraValues: { ...(input.extraValues ?? {}) },
+            });
+            installed.add(input.packageId);
+            installedEnv[input.packageId] = {
+                ...(installedEnv[input.packageId] ?? {}),
+                ...(input.extraValues ?? {}),
+            };
+            openUrls.set(input.packageId, `${new URL(dsmOrigin).protocol}//${new URL(dsmOrigin).hostname}/${webStationAlias(input.packageId)}/`);
+            if (!localAttestations.has(input.packageId)) {
+                localAttestations.set(input.packageId, "local");
+            }
+        },
+        async installFromLocalSpk(input) {
+            installs.push({
+                packageId: input.packageId,
+                version: input.version,
+                source: "local-spk",
+                extraValues: { ...(input.extraValues ?? {}) },
+            });
+            installed.add(input.packageId);
+            installedEnv[input.packageId] = {
+                ...(installedEnv[input.packageId] ?? {}),
+                ...(input.extraValues ?? {}),
+            };
+            openUrls.set(input.packageId, `${new URL(dsmOrigin).protocol}//${new URL(dsmOrigin).hostname}/${webStationAlias(input.packageId)}/`);
+            if (!localAttestations.has(input.packageId)) {
+                localAttestations.set(input.packageId, "local");
+            }
+        },
+        async getInstalledPackageVersion(packageIdentity) {
+            const latest = [...installs].reverse().find((entry) => entry.packageId === packageIdentity);
+            return latest?.version;
+        },
+        async getAttestationInfo(packageIdentity) {
+            return {
+                packageIdentity,
+                attestationKind: localAttestations.get(packageIdentity) ?? (installed.has(packageIdentity) ? "local" : "none"),
+                developmentInstance: packageIdentity.endsWith(".dev"),
+                openUrl: openUrls.get(packageIdentity),
+                readiness: installed.has(packageIdentity) ? "RUNNING" : "NOT_INSTALLED",
+            };
+        },
+        async isPackageInstalled(packageIdentity) {
+            return installed.has(packageIdentity);
+        },
+        async fetchContainerLogs(packageIdentity) {
+            if (!installed.has(packageIdentity)) {
+                return [];
+            }
+            return [`[${packageIdentity}] container ready`];
+        },
+        async smokeRequireLogin() {
+            return { ok: true, username: "admin" };
+        },
+    };
+    for (const packageId of curated) {
+        localAttestations.set(packageId, "app-package");
+    }
+    return host;
+}

package/dist/host/open-url.d.ts

@@ -0,0 +1,5 @@
+export declare function appOriginFromContract(dsmOrigin: string, contract: {
+    package?: unknown;
+    adminprotocol?: unknown;
+    adminport?: unknown;
+}): string | undefined;

package/dist/host/open-url.js

@@ -0,0 +1,13 @@
+import { webStationAlias } from "../contract/web-launch.js";
+export function appOriginFromContract(dsmOrigin, contract) {
+    if (contract.adminport === undefined || contract.adminport === null || contract.adminport === "") {
+        return undefined;
+    }
+    const packageId = String(contract.package ?? "");
+    if (!packageId) {
+        return undefined;
+    }
+    const dsm = new URL(dsmOrigin);
+    const protocol = String(contract.adminprotocol ?? "http");
+    return `${protocol}://${dsm.hostname}/${webStationAlias(packageId)}/`;
+}

package/dist/host/share-lookup.d.ts

@@ -0,0 +1,3 @@
+export declare function shareRealPathFromEntry(entry: Record<string, unknown>, logicalName: string): string | undefined;
+export declare function findShareRealPath(payload: unknown, logicalName: string): string | undefined;
+export declare function lookupSharePathWithSynoagentcli(logicalName: string, profileName?: string): string | undefined;

package/dist/host/share-lookup.js

@@ -0,0 +1,144 @@
+import { spawnSync } from "node:child_process";
+import { resolveHostCredentials } from "./credentials.js";
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return undefined;
+}
+function collectRecords(payload) {
+    const records = [];
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                visit(item);
+            }
+            return;
+        }
+        const record = asRecord(value);
+        if (!record) {
+            return;
+        }
+        if (typeof record.name === "string" || typeof record.share_name === "string") {
+            records.push(record);
+        }
+        for (const child of Object.values(record)) {
+            if (child && typeof child === "object") {
+                visit(child);
+            }
+        }
+    };
+    visit(payload);
+    return records;
+}
+export function shareRealPathFromEntry(entry, logicalName) {
+    const name = String(entry.name ?? entry.share_name ?? "");
+    if (name !== logicalName) {
+        return undefined;
+    }
+    for (const key of ["path", "real_path", "share_path", "mountpoint"]) {
+        const value = entry[key];
+        if (typeof value === "string" && value.startsWith("/")) {
+            return value;
+        }
+    }
+    for (const key of ["vol_path", "volumePath", "volume_path"]) {
+        const value = entry[key];
+        if (typeof value === "string" && value.startsWith("/")) {
+            return `${value.replace(/\/$/, "")}/${logicalName}`;
+        }
+    }
+    return undefined;
+}
+export function findShareRealPath(payload, logicalName) {
+    for (const record of collectRecords(payload)) {
+        const path = shareRealPathFromEntry(record, logicalName);
+        if (path) {
+            return path;
+        }
+    }
+    return undefined;
+}
+function synoagentcli(args, profileName) {
+    const fullArgs = [...args];
+    if (profileName) {
+        fullArgs.push("--host", profileName);
+    }
+    const result = spawnSync("synoagentcli", fullArgs, { encoding: "utf8" });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+    };
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function lookupSharePathWithDsmHttp(logicalName, profileName) {
+    const credentials = resolveHostCredentials(profileName);
+    if (!credentials) {
+        return undefined;
+    }
+    const script = `
+import json, sys, urllib.parse, urllib.request
+origin, account, passwd, name = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
+def call(params):
+    url = origin.rstrip("/") + "/webapi/entry.cgi?" + urllib.parse.urlencode(params)
+    return json.loads(urllib.request.urlopen(url, timeout=8).read())
+login = call({
+    "api": "SYNO.API.Auth",
+    "version": "3",
+    "method": "login",
+    "account": account,
+    "passwd": passwd,
+    "session": "FileStation",
+    "format": "sid",
+})
+sid = (login.get("data") or {}).get("sid")
+if not sid:
+    sys.exit(2)
+try:
+    listed = call({
+        "api": "SYNO.Core.Share",
+        "version": "1",
+        "method": "list",
+        "_sid": sid,
+    })
+    print(json.dumps(listed))
+finally:
+    call({
+        "api": "SYNO.API.Auth",
+        "version": "3",
+        "method": "logout",
+        "session": "FileStation",
+        "_sid": sid,
+    })
+`;
+    const result = spawnSync("python3", ["-c", script, credentials.dsmOrigin, credentials.username, credentials.password, logicalName], { encoding: "utf8" });
+    if (result.status !== 0) {
+        return undefined;
+    }
+    return findShareRealPath(parseJson(result.stdout), logicalName);
+}
+export function lookupSharePathWithSynoagentcli(logicalName, profileName) {
+    const get = synoagentcli(["dsm", "control-panel", "shared-folder", "get", logicalName], profileName);
+    if (get.status === 0) {
+        const fromGet = findShareRealPath(parseJson(get.stdout), logicalName);
+        if (fromGet) {
+            return fromGet;
+        }
+    }
+    const list = synoagentcli(["dsm", "control-panel", "shared-folder", "list"], profileName);
+    if (list.status === 0) {
+        const fromList = findShareRealPath(parseJson(list.stdout), logicalName);
+        if (fromList) {
+            return fromList;
+        }
+    }
+    return lookupSharePathWithDsmHttp(logicalName, profileName);
+}