@synopackageland/cli 0.32.1 → 0.33.1

package/dist/host/install-plan.js

@@ -0,0 +1,157 @@
+import { createHash } from "node:crypto";
+import { CtlError } from "../ctl/errors.js";
+import { familyOfArchToken } from "../build-spk/dsm-arch.js";
+const fail = (code, message, hint = "Check the package source and select a compatible package") => new CtlError(code, message, hint, 3);
+export function compareVersions(a, b) {
+    const x = a.split(/[._-]/).map(Number), y = b.split(/[._-]/).map(Number);
+    if ([...x, ...y].some((n) => !Number.isSafeInteger(n) || n < 0))
+        throw fail("PACKAGE_VERSION_INVALID", "Package versions must contain numeric segments");
+    for (let i = 0; i < Math.max(x.length, y.length); i++)
+        if ((x[i] ?? 0) !== (y[i] ?? 0))
+            return (x[i] ?? 0) - (y[i] ?? 0);
+    return 0;
+}
+export function archMatches(value, arch) {
+    if (value === undefined)
+        return true; // A DSM feed may omit arch after filtering its query.
+    const tokens = Array.isArray(value) ? value : value.split(/\s+/);
+    return tokens.some((token) => token === "noarch" || token === arch || token === familyOfArchToken(arch));
+}
+export function assertCompatible(info, target) {
+    if (!info.arch || !archMatches(info.arch, target.arch))
+        throw fail("PACKAGE_ARCH_MISMATCH", "SPK architecture does not match this NAS");
+    if (info.exclude_arch && archMatches(info.exclude_arch, target.arch))
+        throw fail("PACKAGE_ARCH_MISMATCH", "SPK excludes this NAS architecture");
+    for (const [key, side] of [
+        ["os_min_ver", -1],
+        ["os_max_ver", 1],
+    ]) {
+        if (info[key] &&
+            Math.sign(compareVersions(target.version, info[key])) === side)
+            throw fail("PACKAGE_DSM_MISMATCH", `SPK ${key} is incompatible with this NAS`);
+    }
+}
+export function sourceUrl(source, target) {
+    const url = new URL(source);
+    if (url.protocol !== "https:" || url.username || url.password)
+        throw fail("PACKAGE_SOURCE_INVALID", "Package source must be HTTPS without URL credentials");
+    for (const [key, value] of Object.entries({
+        arch: target.arch,
+        build: target.build,
+        major: target.major,
+        minor: target.minor,
+    }))
+        url.searchParams.set(key, String(value));
+    return url;
+}
+export function selectEntry(entries, id, version, target) {
+    const matching = entries
+        .filter((e) => e.package === id &&
+        (!version || e.version === version) &&
+        archMatches(e.arch, target.arch) &&
+        (!e.os_min_ver || compareVersions(target.version, e.os_min_ver) >= 0) &&
+        (!e.os_max_ver || compareVersions(target.version, e.os_max_ver) <= 0))
+        .sort((a, b) => compareVersions(b.version, a.version));
+    if (!matching.length)
+        throw fail("PACKAGE_NOT_FOUND", `No compatible store release for ${id}${version ? "@" + version : ""}`);
+    const chosen = matching[0];
+    if (matching.filter((e) => e.version === chosen.version).length !== 1)
+        throw fail("PACKAGE_SOURCE_AMBIGUOUS", "Source offers overlapping package architectures");
+    if (!Number.isSafeInteger(chosen.size) ||
+        chosen.size <= 0 ||
+        (!chosen.md5 && !chosen.sha256))
+        throw fail("PACKAGE_PIN_INVALID", "Source must pin SPK size and MD5 or SHA-256");
+    const link = new URL(chosen.link);
+    if (link.protocol !== "https:" || link.username || link.password)
+        throw fail("PACKAGE_LINK_INVALID", "SPK download must be HTTPS without URL credentials");
+    return chosen;
+}
+export function dependencies(value) {
+    if (value === undefined || value === null || value === "")
+        return [];
+    if (typeof value === "string")
+        return value
+            .trim()
+            .split(/[:\s]+/)
+            .map((part) => {
+            const match = /^([A-Za-z][A-Za-z0-9_.+-]*)(?:(>=|<=|==|=|>|<)([0-9][0-9._-]*))?$/.exec(part);
+            if (!match)
+                throw fail("PACKAGE_DEPENDENCY_INVALID", "Unsupported package dependency syntax");
+            return {
+                id: match[1],
+                constraints: match[2] ? { [match[2]]: match[3] } : {},
+            };
+        });
+    if (typeof value === "object" && !Array.isArray(value))
+        return Object.entries(value).map(([id, rules]) => {
+            if (!/^[A-Za-z][A-Za-z0-9_.+-]*$/.test(id))
+                throw fail("PACKAGE_DEPENDENCY_INVALID", "Invalid dependency package ID");
+            if (rules === null)
+                return { id, constraints: {} };
+            if (typeof rules !== "object" ||
+                Array.isArray(rules) ||
+                Object.entries(rules).some(([op, v]) => ![">=", ">", "<=", "<", "==", "="].includes(op) ||
+                    typeof v !== "string" ||
+                    !/^\d[\d._-]*$/.test(v)))
+                throw fail("PACKAGE_DEPENDENCY_INVALID", "Unsupported package dependency rules");
+            return { id, constraints: rules };
+        });
+    throw fail("PACKAGE_DEPENDENCY_INVALID", "Unsupported package dependency format");
+}
+export function satisfies(version, dependency) {
+    return Object.entries(dependency.constraints).every(([op, want]) => {
+        const c = compareVersions(version, want);
+        return op === ">="
+            ? c >= 0
+            : op === ">"
+                ? c > 0
+                : op === "<="
+                    ? c <= 0
+                    : op === "<"
+                        ? c < 0
+                        : c === 0;
+    });
+}
+export function resolveInstallPlan(root, entries, target, installed) {
+    const plan = [], visiting = new Set(), chosen = new Map();
+    const visit = (entry) => {
+        if (visiting.has(entry.package))
+            throw fail("PACKAGE_DEPENDENCY_CYCLE", "Package dependency cycle detected");
+        if (chosen.has(entry.package))
+            return;
+        visiting.add(entry.package);
+        for (const dep of dependencies(entry.deppkgs)) {
+            const existing = chosen.get(dep.id);
+            if (existing) {
+                if (!satisfies(existing.version, dep))
+                    throw fail("PACKAGE_DEPENDENCY_CONFLICT", `Conflicting dependency ${dep.id}`);
+                continue;
+            }
+            if (installed.has(dep.id) && satisfies(installed.get(dep.id), dep))
+                continue;
+            const candidates = entries.filter((e) => e.package === dep.id && satisfies(e.version, dep));
+            if (!candidates.length)
+                throw fail("PACKAGE_DEPENDENCY_REQUIRED", `Install required Synology package ${dep.id}${Object.entries(dep.constraints)
+                    .map(([k, v]) => k + v)
+                    .join(",")} first`, "Install the dependency in DSM Package Center, then retry");
+            visit(selectEntry(candidates, dep.id, undefined, target));
+        }
+        visiting.delete(entry.package);
+        chosen.set(entry.package, entry);
+        plan.push(entry);
+    };
+    visit(root);
+    return plan;
+}
+export function verifyPins(bytes, entry) {
+    if (bytes.length !== entry.size)
+        throw fail("PACKAGE_SIZE_MISMATCH", "Downloaded SPK size differs from the feed pin");
+    for (const algorithm of ["md5", "sha256"]) {
+        const pin = entry[algorithm];
+        if (pin === undefined)
+            continue;
+        if (!new RegExp(`^[a-fA-F0-9]{${algorithm === "md5" ? 32 : 64}}$`).test(pin) ||
+            createHash(algorithm).update(bytes).digest("hex") !== pin.toLowerCase())
+            throw fail("PACKAGE_DIGEST_MISMATCH", `Downloaded SPK ${algorithm.toUpperCase()} differs from the feed pin`);
+    }
+}

package/dist/host/package-commands.d.ts

@@ -0,0 +1,75 @@
+import { type NasConnection } from "./connection.js";
+import { type NasTarget, type StoreEntry } from "./install-plan.js";
+export declare const DEFAULT_PACKAGE_SOURCE = "https://packages.synopkgland.com";
+export declare function packageId(value: string): string;
+export declare function nasTarget(nas: NasConnection): Promise<NasTarget>;
+export declare function readFeed(source: string, target: NasTarget): Promise<StoreEntry[]>;
+export interface InstallOptions {
+    host?: string;
+    source?: string;
+    param?: Record<string, string>;
+    yes?: boolean;
+    dryRun?: boolean;
+}
+export declare function installPackage(spec: string, options?: InstallOptions, connection?: NasConnection): Promise<{
+    host: string;
+    target: NasTarget;
+    source: string;
+    packages: {
+        signed?: boolean | undefined;
+        package: string;
+        version: string;
+        size: number;
+        action: string;
+    }[];
+    parameters: string[];
+    dryRun: boolean;
+} | {
+    status: import("./catalog-install.js").InstalledPackageState | undefined;
+    host: string;
+    target: NasTarget;
+    source: string;
+    packages: {
+        signed?: boolean | undefined;
+        package: string;
+        version: string;
+        size: number;
+        action: string;
+    }[];
+    parameters: string[];
+}>;
+export declare function uninstallPackage(id: string, options?: {
+    host?: string;
+    yes?: boolean;
+    dryRun?: boolean;
+}): Promise<{
+    dryRun: boolean;
+    host: string;
+    package: string;
+    action: string;
+    installed?: undefined;
+} | {
+    host: string;
+    package: string;
+    installed: boolean;
+    dryRun?: undefined;
+    action?: undefined;
+}>;
+export declare function packageStatus(id: string, host?: string): Promise<{
+    installed: boolean;
+    version?: string;
+    status?: string;
+    error?: {
+        code?: number;
+        description?: string;
+        workerMsg?: unknown[];
+    };
+    brokenBy?: string;
+    stage?: string;
+    lastStage?: string;
+    statusCode?: number;
+    statusDescription?: string;
+    statusOrigin?: string;
+    host: string;
+    package: string;
+}>;

package/dist/host/package-commands.js

@@ -0,0 +1,205 @@
+import { mkdtempSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { CtlError } from "../ctl/errors.js";
+import { inspectAnySpk } from "../spk/inspect.js";
+import { connectNas, requireAdministrator, } from "./connection.js";
+import { fetchPackageSource } from "../package-source.js";
+import { fetchInstalledPackageState, installPackageFromLocalSpk, uninstallPackageFromDsm, } from "./catalog-install.js";
+import { assertCompatible, sourceUrl, selectEntry, resolveInstallPlan, verifyPins, compareVersions, } from "./install-plan.js";
+export const DEFAULT_PACKAGE_SOURCE = "https://packages.synopkgland.com";
+const fail = (code, message, hint = "Check Package Center and retry") => new CtlError(code, message, hint, 3);
+export function packageId(value) {
+    if (!/^[A-Za-z][A-Za-z0-9_.+-]{0,127}$/.test(value))
+        throw fail("PACKAGE_ID_INVALID", "Invalid package ID");
+    return value;
+}
+export async function nasTarget(nas) {
+    const packageInfo = await nas.call("SYNO.Core.Package.Info", "get", 1);
+    const info = await nas.call("SYNO.DSM.Info", "getinfo", 2);
+    const config = packageInfo?.config;
+    const unique = config?.ds_unique;
+    const arch = typeof unique === "string" && unique.startsWith("synology_")
+        ? unique.slice(9, unique.lastIndexOf("_"))
+        : undefined;
+    const build = Number(config?.ds_build);
+    const version = typeof info.version_string === "string"
+        ? /\b(\d+\.\d+(?:\.\d+)?)-\d+/.exec(info.version_string)?.[1]
+        : undefined;
+    if (typeof arch !== "string" ||
+        !/^\w+$/.test(arch) ||
+        !Number.isSafeInteger(build) ||
+        build < 1 ||
+        typeof version !== "string" ||
+        !/^\d+\.\d+(?:\.\d+)?$/.test(version))
+        throw fail("NAS_TARGET_UNKNOWN", "DSM did not report a usable platform and build", "Check NAS system information; no architecture was guessed");
+    const [major, minor] = version.split(".").map(Number);
+    return { arch, version: `${version}-${build}`, major, minor, build };
+}
+export async function readFeed(source, target) {
+    const response = await fetchPackageSource(sourceUrl(source, target).href);
+    if (!response.ok)
+        throw fail("PACKAGE_SOURCE_FAILED", `Package source returned HTTP ${response.status}`);
+    const body = (await response.json());
+    if (!Array.isArray(body?.packages) || body.packages.length > 4096)
+        throw fail("PACKAGE_SOURCE_INVALID", "Package source returned an invalid package list");
+    return body.packages;
+}
+async function inventory(nas) {
+    const data = await nas.call("SYNO.Core.Package", "list", 2, {
+        additional: '["status"]',
+        ignore_hidden: "false",
+    });
+    if (!Array.isArray(data?.packages) ||
+        (data.total !== undefined && data.total !== data.packages.length))
+        throw fail("NAS_INVENTORY_INVALID", "Installed package inventory is incomplete");
+    return new Map(data.packages.map((p) => [p.id, p.version]));
+}
+async function confirm(action, yes) {
+    if (yes)
+        return;
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        throw fail("PACKAGE_CONFIRM_REQUIRED", "Package changes require confirmation", `Use --yes to ${action} non-interactively`);
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        if (!/^y(es)?$/i.test(await rl.question(`${action}? [y/N] `)))
+            throw fail("PACKAGE_CANCELLED", "Package operation cancelled", "No changes were made");
+    }
+    finally {
+        rl.close();
+    }
+}
+function checkSpk(report, target) {
+    if (!report.dsm.ok ||
+        report.findings.length ||
+        !report.package ||
+        !report.version)
+        throw fail("PACKAGE_INSPECT_FAILED", "SPK inspection failed", "Run synopkgland inspect <file.spk> for the detailed checks");
+    assertCompatible(report.info ?? {}, target);
+}
+export async function installPackage(spec, options = {}, connection) {
+    const stage = mkdtempSync(join(tmpdir(), "synopkgland-install-"));
+    try {
+        const local = /\.spk$/i.test(spec) ||
+            spec.startsWith(".") ||
+            spec.startsWith("/") ||
+            spec.includes("\\");
+        let report;
+        const localFile = join(stage, "local.spk");
+        if (local) {
+            writeFileSync(localFile, readFileSync(resolve(spec)), { mode: 0o600 });
+            report = await inspectAnySpk(localFile);
+            if (!report.dsm.ok || report.findings.length)
+                throw fail("PACKAGE_INSPECT_FAILED", "SPK inspection failed", "Run synopkgland inspect <file.spk> for details");
+        }
+        const nas = connection ?? (await connectNas(options.host)), target = await nasTarget(nas), installed = await inventory(nas);
+        if (report)
+            checkSpk(report, target);
+        const source = options.source ?? DEFAULT_PACKAGE_SOURCE;
+        let entries = [];
+        if (!local || report?.info?.install_dep_packages)
+            entries = await readFeed(source, target);
+        let root;
+        if (report) {
+            root = {
+                package: packageId(report.package),
+                version: report.version,
+                link: "",
+                size: readFileSync(localFile).length,
+                deppkgs: report.info?.install_dep_packages,
+            };
+        }
+        else {
+            const match = /^([^@]+)(?:@([0-9][0-9._-]*))?$/.exec(spec);
+            if (!match)
+                throw fail("PACKAGE_SPEC_INVALID", "Use <package-id>[@version] or a local .spk");
+            root = selectEntry(entries, packageId(match[1]), match[2], target);
+        }
+        const plan = resolveInstallPlan(root, entries, target, installed);
+        for (const item of plan)
+            if (installed.has(item.package) &&
+                compareVersions(item.version, installed.get(item.package)) < 0)
+                throw fail("PACKAGE_DOWNGRADE_REFUSED", `Refusing downgrade of ${item.package}`, "Choose the installed version or a newer release");
+        const publicPlan = {
+            host: nas.name,
+            target,
+            source: local ? "local" : source,
+            packages: plan.map((item) => ({
+                package: item.package,
+                version: item.version,
+                size: item.size,
+                action: installed.has(item.package) ? "upgrade" : "install",
+                ...(item.package === root.package && report
+                    ? { signed: report.signed }
+                    : {}),
+            })),
+            parameters: Object.keys(options.param ?? {}),
+        };
+        if (options.dryRun)
+            return { dryRun: true, ...publicPlan };
+        await requireAdministrator(nas);
+        await confirm(`Install ${plan.map((e) => e.package + "@" + e.version).join(", ")}`, options.yes);
+        // Download, verify and inspect the entire plan before the first NAS write.
+        const files = new Map();
+        for (const entry of plan) {
+            let file = localFile;
+            if (!local || entry.package !== root.package) {
+                const response = await fetchPackageSource(entry.link);
+                if (!response.ok)
+                    throw fail("PACKAGE_DOWNLOAD_FAILED", `SPK download returned HTTP ${response.status}`);
+                const bytes = Buffer.from(await response.arrayBuffer());
+                verifyPins(bytes, entry);
+                file = join(stage, `${files.size}.spk`);
+                writeFileSync(file, bytes, { mode: 0o600 });
+            }
+            const checked = await inspectAnySpk(file);
+            checkSpk(checked, target);
+            if (checked.package !== entry.package ||
+                checked.version !== entry.version)
+                throw fail("PACKAGE_IDENTITY_MISMATCH", "Downloaded SPK identity differs from the selected release");
+            files.set(entry.package, file);
+        }
+        for (const entry of plan)
+            await installPackageFromLocalSpk({
+                dsmOrigin: nas.session.origin,
+                cookieHeader: nas.session.cookie,
+                packageId: entry.package,
+                version: entry.version,
+                spkPath: files.get(entry.package),
+                extraValues: entry.package === root.package ? options.param : undefined,
+            });
+        return {
+            ...publicPlan,
+            status: await fetchInstalledPackageState(nas.session.origin, nas.session.cookie, root.package),
+        };
+    }
+    finally {
+        rmSync(stage, { recursive: true, force: true });
+    }
+}
+export async function uninstallPackage(id, options = {}) {
+    packageId(id);
+    const nas = await connectNas(options.host);
+    const state = await fetchInstalledPackageState(nas.session.origin, nas.session.cookie, id);
+    if (!state?.installed)
+        throw fail("PACKAGE_NOT_INSTALLED", `Package ${id} is not installed`);
+    if (options.dryRun)
+        return { dryRun: true, host: nas.name, package: id, action: "uninstall" };
+    await requireAdministrator(nas);
+    await confirm(`Uninstall ${id} (package uninstall hooks may remove data)`, options.yes);
+    await uninstallPackageFromDsm({
+        dsmOrigin: nas.session.origin,
+        cookieHeader: nas.session.cookie,
+        packageId: id,
+    });
+    return { host: nas.name, package: id, installed: false };
+}
+export async function packageStatus(id, host) {
+    packageId(id);
+    const nas = await connectNas(host);
+    const state = await fetchInstalledPackageState(nas.session.origin, nas.session.cookie, id);
+    if (!state)
+        throw fail("PACKAGE_STATUS_UNKNOWN", "DSM did not return a verifiable package state");
+    return { host: nas.name, package: id, ...state };
+}

package/dist/host/port-info-lookup.d.ts

@@ -1,7 +1,7 @@
 import type { PortInfoEntry } from "./port-info.js";
 export type PortInfoHttpRequest = (url: string, init?: RequestInit) => Promise<Response>;
 /**
- * Parses the native DSM response, not a synoagentcli operation envelope.
+ * Parses the native DSM response, not a shared host operation envelope.
  * `undefined` means "cannot tell" and deliberately allows deployment to
  * continue. An empty `port_info` list has the same fail-open meaning.
  */

package/dist/host/port-info-lookup.js

@@ -1,3 +1,4 @@
+import { CtlError } from '../ctl/errors.js';
 import { dsmFetch } from "./dsm-http.js";
 const PORT_INFO_API = "SYNO.Core.Service.PortInfo";
 function asRecord(value) {
@@ -20,7 +21,7 @@ function validPortRange(value) {
         end <= 65535);
 }
 /**
- * Parses the native DSM response, not a synoagentcli operation envelope.
+ * Parses the native DSM response, not a shared host operation envelope.
  * `undefined` means "cannot tell" and deliberately allows deployment to
  * continue. An empty `port_info` list has the same fail-open meaning.
  */
@@ -81,7 +82,9 @@ export async function fetchPortInfo(dsmOrigin, cookieHeader, request = dsmFetch)
         }
         return parsePortInfo(await response.json());
     }
-    catch {
+    catch (error) {
+        if (error instanceof CtlError)
+            throw error;
         return undefined;
     }
 }

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

@@ -1,5 +1,6 @@
 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 findShareNames(payload: unknown): string[];
-export declare function lookupSharePathWithSynoagentcli(logicalName: string, profileName?: string): string | undefined;
-export declare function listShareNamesWithSynoagentcli(profileName?: string): string[];
+/** Query shares through the caller's authenticated DSM transport. */
+export declare function lookupSharePath(logicalName: string, call: (api: string, method: string, version: number, params?: Record<string, string>) => Promise<any>): Promise<string | undefined>;
+export declare function listShareNames(call: (api: string, method: string, version: number, params?: Record<string, string>) => Promise<any>): Promise<string[]>;

package/dist/host/share-lookup.js

@@ -1,5 +1,3 @@
-import { spawnSync } from "node:child_process";
-import { resolveHostCredentials } from "./credentials.js";
 function asRecord(value) {
     if (value && typeof value === "object" && !Array.isArray(value)) {
         return value;
@@ -69,93 +67,9 @@ export function findShareNames(payload) {
     }
     return [...names];
 }
-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);
-}
-export function listShareNamesWithSynoagentcli(profileName) {
-    const list = synoagentcli(["dsm", "control-panel", "shared-folder", "list"], profileName);
-    if (list.status !== 0) {
-        return [];
-    }
-    return findShareNames(parseJson(list.stdout));
+/** Query shares through the caller's authenticated DSM transport. */
+export async function lookupSharePath(logicalName, call) {
+    const body = await call('SYNO.Core.Share', 'list', 1, { additional: '["real_path"]' });
+    return findShareRealPath(body, logicalName);
 }
+export async function listShareNames(call) { return findShareNames(await call('SYNO.Core.Share', 'list', 1)); }

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

@@ -11,7 +11,7 @@ import type { SharePermissionRow } from "./share-permission.js";
  * The APIs used were confirmed present on DSM 7.4 (the test NAS):
  * `SYNO.Core.Share.Permission`, `SYNO.Core.Group`, `SYNO.Core.Group.Member`.
  * `SYNO.Core.User.Group` also exists on the NAS but has no generated
- * synoagentcli operation, which is why membership is derived group-by-group.
+ * CLI operation, which is why membership is derived group-by-group.
  */
 export type DsmApiCall = (operationId: string, params: Record<string, string>) => Promise<unknown>;
 export declare function parseSharePermissionRows(payload: unknown): SharePermissionRow[] | undefined;
@@ -19,5 +19,5 @@ export declare function parseGroupNames(payload: unknown): string[] | undefined;
 export declare function parseGroupMemberNames(payload: unknown): string[] | undefined;
 export declare function fetchSharePermissions(shareName: string, call: DsmApiCall): Promise<SharePermissionListing | undefined>;
 export declare function fetchUserGroups(userName: string, call: DsmApiCall): Promise<string[] | undefined>;
-/** synoagentcli-backed `DsmApiCall`, matching how the rest of the host client talks to DSM. */
-export declare function createSynoagentcliApiCall(profileName?: string): DsmApiCall;
+/** Adapt fixed operation IDs to direct DSM WebAPI requests. */
+export declare function createDsmApiCall(call: (api: string, method: string, version: number, params: Record<string, string>) => Promise<unknown>): DsmApiCall;