@synopackageland/cli 0.1.0

package/dist/host/catalog-install.js

@@ -0,0 +1,326 @@
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dsmFetch } from "./dsm-http.js";
+function normalizeDeppkgs(deppkgs) {
+    if (typeof deppkgs === "string") {
+        const match = /^([^><=]+)(>=|>|<=|<|==)(.+)$/.exec(deppkgs.trim());
+        if (match) {
+            return { [match[1]]: { [match[2]]: match[3] } };
+        }
+    }
+    return deppkgs;
+}
+function jsonApiParam(value) {
+    return JSON.stringify(value ?? null);
+}
+function extractSid(cookieHeader) {
+    const match = /(?:^|;\s*)id=([^;]+)/.exec(cookieHeader);
+    if (!match?.[1]) {
+        throw new Error("DSM session cookie missing id=");
+    }
+    return match[1];
+}
+async function dsmWebApi(dsmOrigin, cookieHeader, params, options = {}) {
+    const query = new URLSearchParams(params);
+    const response = await dsmFetch(`${dsmOrigin}/webapi/entry.cgi?${query.toString()}`, {
+        headers: { cookie: cookieHeader },
+    });
+    const body = (await response.json());
+    const errorCode = body.error?.code;
+    if (!body.success && !(errorCode && options.allowErrorCodes?.includes(errorCode))) {
+        throw new Error(`DSM ${params.api}/${params.method} failed: ${JSON.stringify(body.error ?? body)}`);
+    }
+    return body;
+}
+async function fetchCatalogEntry(options) {
+    const sid = extractSid(options.cookieHeader);
+    const list = await dsmWebApi(options.dsmOrigin, options.cookieHeader, {
+        api: "SYNO.Core.Package.Server",
+        version: "2",
+        method: "list",
+        blforcereload: "true",
+        blloadothers: "true",
+        _sid: sid,
+    });
+    const data = list.data;
+    const entries = [...(data.packages ?? []), ...(data.beta_packages ?? [])];
+    const entry = entries.find((item) => item.package === options.packageId);
+    if (!entry) {
+        throw new Error(`Package ${options.packageId} not found in Package Source catalog`);
+    }
+    return entry;
+}
+async function fetchCatalogEntryFromOrigin(origin, packageId) {
+    const catalogUrl = `${origin.replace(/\/$/, "")}/?arch=noarch&build=69057&major=7`;
+    try {
+        const response = await dsmFetch(catalogUrl);
+        if (!response.ok) {
+            return undefined;
+        }
+        const data = (await response.json());
+        const entries = [...(data.packages ?? []), ...(data.beta_packages ?? [])];
+        return entries.find((item) => item.package === packageId);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function waitForCatalogEntry(options, expectedVersion) {
+    const deadline = Date.now() + 5 * 60 * 1000;
+    let lastVersion;
+    while (Date.now() < deadline) {
+        const originEntry = options.packageSourceOrigin
+            ? await fetchCatalogEntryFromOrigin(options.packageSourceOrigin, options.packageId)
+            : undefined;
+        const entry = originEntry ?? await fetchCatalogEntry(options);
+        lastVersion = entry.version;
+        if (entry.version === expectedVersion) {
+            return entry;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+    }
+    throw new Error(`Package ${options.packageId} catalog shows ${lastVersion ?? "unknown"}; expected ${expectedVersion}`);
+}
+function readInstalledPackageState(packageId, profileName) {
+    const args = ["dsm", "package-center", "get", packageId];
+    if (profileName) {
+        args.push("--host", profileName);
+    }
+    const result = spawnSync("synoagentcli", args, { encoding: "utf8" });
+    if (result.status !== 0) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(result.stdout);
+        if (!parsed.data?.installed) {
+            return { installed: false, version: parsed.data?.version, status: parsed.data?.status };
+        }
+        return { installed: true, version: parsed.data.version, status: parsed.data.status };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function packageStateFromListPayload(payload, packageId) {
+    const record = payload && typeof payload === "object" ? payload : undefined;
+    const data = record?.data && typeof record.data === "object" ? record.data : record;
+    const packages = Array.isArray(data?.packages) ? data.packages : [];
+    const match = packages.find((item) => item && typeof item === "object" && item.id === packageId);
+    if (!match) {
+        return { installed: false };
+    }
+    const additional = match.additional;
+    const installedPath = additional?.installed_info?.path;
+    const installed = Boolean(installedPath) || match.installed === true;
+    const status = typeof additional?.status === "string" ? additional.status : undefined;
+    const version = typeof match.version === "string" ? match.version : undefined;
+    return { installed, version, status };
+}
+export async function fetchInstalledPackageState(dsmOrigin, cookieHeader, packageId) {
+    try {
+        const body = await dsmWebApi(dsmOrigin, cookieHeader, {
+            api: "SYNO.Core.Package",
+            version: "2",
+            method: "list",
+            additional: JSON.stringify(["status", "installed_info"]),
+            ignore_hidden: "false",
+        });
+        return packageStateFromListPayload(body, packageId);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isPackageInstalled(packageId, profileName) {
+    const state = readInstalledPackageState(packageId, profileName);
+    return state?.installed === true;
+}
+function installStatusIsBroken(status) {
+    if (!status) {
+        return false;
+    }
+    return /(broken|error|fail|installing|150)/i.test(status);
+}
+export async function waitForInstalledVersion(readState, options) {
+    const deadline = Date.now() + (options.deadlineMs ?? 15 * 60 * 1000);
+    const pollMs = options.pollMs ?? 5000;
+    while (Date.now() < deadline) {
+        const state = await readState();
+        if (state?.installed && installStatusIsBroken(state.status)) {
+            throw new Error(`Package ${options.packageId} install did not complete (Package Center status ${state.status}). Check synopkg postinst / webservice acquire.`);
+        }
+        if (state?.installed) {
+            if (!options.expectedVersion || state.version === options.expectedVersion) {
+                return;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+    throw new Error(options.expectedVersion
+        ? `Timed out waiting for ${options.packageId} to reach version ${options.expectedVersion}`
+        : `Timed out waiting for ${options.packageId} to install from catalog`);
+}
+export function catalogInstallationRequests(entry, installed, sid, volumePath) {
+    const install = {
+        api: "SYNO.Core.Package.Installation",
+        version: "1",
+        method: "install",
+        name: jsonApiParam(entry.package),
+        is_syno: "false",
+        beta: String(Boolean(entry.beta)),
+        url: jsonApiParam(entry.link),
+        checksum: jsonApiParam(entry.md5),
+        filesize: String(entry.size),
+        type: "0",
+        blqinst: String(Boolean(entry.qinst)),
+        operation: jsonApiParam(installed ? "upgrade" : "install"),
+        _sid: sid,
+    };
+    if (volumePath) {
+        install.volume_path = jsonApiParam(volumePath);
+    }
+    return {
+        check: {
+            api: "SYNO.Core.Package.Installation",
+            version: "2",
+            method: "check",
+            depsers: jsonApiParam(""),
+            deppkgs: jsonApiParam(normalizeDeppkgs(entry.deppkgs)),
+            conflictpkgs: jsonApiParam(null),
+            breakpkgs: jsonApiParam(entry.breakpkgs),
+            replacepkgs: jsonApiParam(entry.replacepkgs),
+            ver: jsonApiParam(entry.version),
+            size: String(entry.size),
+            id: jsonApiParam(entry.package),
+            blupgrade: installed ? "true" : "false",
+            install_type: jsonApiParam(""),
+            install_on_cold_storage: jsonApiParam(""),
+            blCheckDep: "true",
+            _sid: sid,
+        },
+        install,
+    };
+}
+export function catalogCompoundSteps(uploaded, entry, options) {
+    return [
+        {
+            api: "SYNO.Core.Package.Installation",
+            method: "check",
+            version: 2,
+            id: uploaded.id,
+            ver: entry.version,
+            size: entry.size,
+            install_type: "",
+            install_on_cold_storage: false,
+            breakpkgs: null,
+            blCheckDep: true,
+            replacepkgs: null,
+            blupgrade: options.blupgrade,
+        },
+        {
+            api: "SYNO.Core.Package.Installation",
+            method: "install",
+            version: 1,
+            extra_values: JSON.stringify(options.extraValues ?? {}),
+            type: 0,
+            check_codesign: false,
+            force: false,
+            installrunpackage: true,
+            task_id: uploaded.taskId,
+        },
+        {
+            api: "SYNO.Core.Package",
+            method: "get",
+            version: 1,
+            id: uploaded.id,
+            additional: ["status", "dsm_apps"],
+        },
+    ];
+}
+export function catalogUpgradeCompoundSteps(uploaded, entry, extraValues) {
+    return catalogCompoundSteps(uploaded, entry, { blupgrade: true, extraValues });
+}
+async function uploadLocalSpk(options, sid) {
+    const bytes = readFileSync(options.spkPath);
+    const form = new FormData();
+    form.append("api", "SYNO.Core.Package.Installation");
+    form.append("method", "upload");
+    form.append("version", "1");
+    form.append("_sid", sid);
+    form.append("file", new Blob([bytes]), `${options.packageId}.spk`);
+    const uploadResponse = await dsmFetch(`${options.dsmOrigin}/webapi/entry.cgi`, {
+        method: "POST",
+        headers: { cookie: options.cookieHeader },
+        body: form,
+    });
+    const body = (await uploadResponse.json());
+    if (!body.success || !body.data?.id || !body.data.task_id) {
+        throw new Error(`DSM SYNO.Core.Package.Installation/upload failed: ${JSON.stringify(body.error ?? body)}`);
+    }
+    return { id: body.data.id, taskId: body.data.task_id };
+}
+export async function installPackageFromLocalSpk(options) {
+    const sid = extractSid(options.cookieHeader);
+    const dsmState = await fetchInstalledPackageState(options.dsmOrigin, options.cookieHeader, options.packageId);
+    const installed = dsmState?.installed === true || isPackageInstalled(options.packageId, options.profileName);
+    const uploaded = await uploadLocalSpk(options, sid);
+    const compound = JSON.stringify(catalogCompoundSteps(uploaded, { version: options.version, size: readFileSync(options.spkPath).byteLength }, { blupgrade: installed, extraValues: options.extraValues }));
+    await dsmWebApi(options.dsmOrigin, options.cookieHeader, {
+        api: "SYNO.Entry.Request",
+        version: "1",
+        method: "request",
+        stop_when_error: "true",
+        mode: jsonApiParam("sequential"),
+        compound,
+        _sid: sid,
+    });
+    await waitForInstalledVersion(async () => (await fetchInstalledPackageState(options.dsmOrigin, options.cookieHeader, options.packageId)) ??
+        readInstalledPackageState(options.packageId, options.profileName), { packageId: options.packageId, expectedVersion: options.version });
+}
+async function uploadCatalogSpk(options, entry, sid) {
+    const response = await dsmFetch(entry.link);
+    if (!response.ok) {
+        throw new Error(`Failed to download catalog SPK for ${entry.package}: HTTP ${response.status}`);
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    const form = new FormData();
+    form.append("api", "SYNO.Core.Package.Installation");
+    form.append("method", "upload");
+    form.append("version", "1");
+    form.append("_sid", sid);
+    form.append("file", new Blob([bytes]), `${entry.package}.spk`);
+    const uploadResponse = await dsmFetch(`${options.dsmOrigin}/webapi/entry.cgi`, {
+        method: "POST",
+        headers: { cookie: options.cookieHeader },
+        body: form,
+    });
+    const body = (await uploadResponse.json());
+    if (!body.success || !body.data?.id || !body.data.task_id) {
+        throw new Error(`DSM SYNO.Core.Package.Installation/upload failed: ${JSON.stringify(body.error ?? body)}`);
+    }
+    return { id: body.data.id, taskId: body.data.task_id };
+}
+async function installCatalogViaUpload(options, entry, sid, installed) {
+    const uploaded = await uploadCatalogSpk(options, entry, sid);
+    const compound = JSON.stringify(catalogCompoundSteps(uploaded, entry, { blupgrade: installed, extraValues: options.extraValues }));
+    await dsmWebApi(options.dsmOrigin, options.cookieHeader, {
+        api: "SYNO.Entry.Request",
+        version: "1",
+        method: "request",
+        stop_when_error: "true",
+        mode: jsonApiParam("sequential"),
+        compound,
+        _sid: sid,
+    });
+}
+export async function installPackageFromCatalog(options) {
+    const entry = options.expectedVersion
+        ? await waitForCatalogEntry(options, options.expectedVersion)
+        : await fetchCatalogEntry(options);
+    const sid = extractSid(options.cookieHeader);
+    const dsmState = await fetchInstalledPackageState(options.dsmOrigin, options.cookieHeader, options.packageId);
+    const installed = dsmState?.installed === true || isPackageInstalled(options.packageId, options.profileName);
+    await installCatalogViaUpload(options, entry, sid, installed);
+    await waitForInstalledVersion(async () => (await fetchInstalledPackageState(options.dsmOrigin, options.cookieHeader, options.packageId)) ??
+        readInstalledPackageState(options.packageId, options.profileName), { packageId: options.packageId, expectedVersion: entry.version });
+}

package/dist/host/credentials.d.ts

@@ -0,0 +1,2 @@
+import type { HostCredentials } from "./types.js";
+export declare function resolveHostCredentials(hostName?: string): HostCredentials | null;

package/dist/host/credentials.js

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function resolveHostCredentials(hostName) {
+    const settingsPath = join(homedir(), ".synoagentcli", "setting.json");
+    let settings;
+    try {
+        settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    }
+    catch {
+        return fromEnv();
+    }
+    const selected = hostName ?? settings.defaultHost ?? "default";
+    const profile = settings.hosts?.[selected] ?? settings.hosts?.[settings.defaultHost ?? "default"];
+    const username = profile?.username ?? profile?.auth?.username;
+    const password = profile?.password ?? profile?.auth?.password;
+    if (profile?.url && username && password) {
+        return {
+            dsmOrigin: profile.url,
+            username,
+            password,
+        };
+    }
+    if (profile?.url) {
+        return fromEnv(profile.url);
+    }
+    return fromEnv();
+}
+function fromEnv(urlOverride) {
+    const dsmOrigin = urlOverride ?? process.env.DSM_URL;
+    const password = process.env.DSM_PASSWORD;
+    const username = process.env.DSM_USERNAME ?? "admin";
+    if (!dsmOrigin || !password) {
+        return null;
+    }
+    return { dsmOrigin, username, password };
+}

package/dist/host/digests.d.ts

@@ -0,0 +1,5 @@
+import type { ProjectRoot } from "../discovery.js";
+export declare function digestString(value: string): string;
+export declare function digestDirectory(root: string): string;
+export declare function digestProjectContract(project: ProjectRoot): string;
+export declare function digestProjectBundle(project: ProjectRoot): string;

package/dist/host/digests.js

@@ -0,0 +1,55 @@
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+export function digestString(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function digestDirectory(root) {
+    const hash = createHash("sha256");
+    for (const relative of walkFiles(root)) {
+        hash.update(relative);
+        hash.update("\0");
+        hash.update(readFileSync(join(root, relative)));
+        hash.update("\0");
+    }
+    return hash.digest("hex");
+}
+export function digestProjectContract(project) {
+    return digestString(readFileSync(project.contractPath, "utf8"));
+}
+export function digestProjectBundle(project) {
+    const staging = mkdtempSync(join(tmpdir(), "syno-bundle-digest-"));
+    try {
+        const packageDir = join(staging, "package");
+        mkdirSync(packageDir, { recursive: true });
+        cpSync(project.composePath, join(packageDir, "compose.yaml"));
+        cpSync(project.contractPath, join(packageDir, "synology-app.yaml"));
+        const htmlDir = join(project.root, "html");
+        if (existsSync(htmlDir)) {
+            cpSync(htmlDir, join(packageDir, "html"), { recursive: true });
+        }
+        return digestDirectory(packageDir);
+    }
+    finally {
+        rmSync(staging, { recursive: true, force: true });
+    }
+}
+function walkFiles(root, prefix = "") {
+    const files = [];
+    for (const entry of readdirSync(root).sort(comparePosixPaths)) {
+        const relative = prefix ? `${prefix}/${entry}` : entry;
+        const absolute = join(root, entry);
+        const stat = statSync(absolute);
+        if (stat.isDirectory()) {
+            files.push(...walkFiles(absolute, relative));
+        }
+        else if (stat.isFile()) {
+            files.push(relative);
+        }
+    }
+    return files;
+}
+function comparePosixPaths(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

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

@@ -0,0 +1,6 @@
+import type { HostCredentials, NasHost } from "./types.js";
+export interface CreateNasHostOptions {
+    host?: string;
+    credentials?: HostCredentials;
+}
+export declare function createNasHost(options?: CreateNasHostOptions): NasHost | null;