@synopackageland/cli 0.9.4 → 0.9.6

package/dist/standalone/uninstall-hook.js

@@ -0,0 +1,71 @@
+/** The syslog tag of a failed or timed-out App uninstall hook. */
+export const UNINSTALL_SYSLOG_TAG = "synopkgland-uninstall";
+const TRUE_VALUES = "true|True|TRUE|yes|1";
+/** A fixed token in single quotes; only the package's own directories expand. */
+function word(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`
+        .replaceAll("${SYNOPKG_PKGDEST}", `'"$hook_dest"'`)
+        .replaceAll("${SYNOPKG_PKGVAR}", `'"$hook_var"'`);
+}
+function wizardFlag(variable, keys) {
+    const values = keys.flatMap(key => [`"\${${key}:-}"`, `"\${wizard_${key}:-}"`]).join(" ");
+    return `  for flag in ${values}; do\n    case "$flag" in\n      ${TRUE_VALUES}) ${variable}=1 ;;\n    esac\n  done\n`;
+}
+/**
+ * `synopkgland_uninstall_hook`: runs `uninstall.purge` as the package account
+ * with a fixed environment and the wizard's two answers, within its timeout.
+ * A failure is logged and never blocks the uninstall. It sets
+ * `synopkgland_purge_args` for the executor purge request.
+ */
+export function renderUninstallHook(manifest) {
+    const purge = manifest.uninstall?.purge;
+    if (!purge)
+        return "";
+    const pkg = manifest.package;
+    const env = [
+        "PATH=/usr/bin:/bin", 'HOME="$hook_var"', 'TMPDIR="$hook_var/tmp"',
+        ...Object.entries(purge.env).map(([key, value]) => `${key}=${word(value)}`),
+        'SYNOPKGLAND_DELETE_STATE="$delete_state"', 'SYNOPKGLAND_REMOVE_DATA="$remove_data"',
+    ].join(" ");
+    const argv = [`"$hook_dest"/${word(purge.exec)}`, ...purge.args.map(word)].join(" ");
+    const failed = `${pkg} uninstall hook failed: $hook_failure`;
+    const logged = `${failed}; output in $hook_var/uninstall-hook.log`;
+    return `synopkgland_purge_args=
+synopkgland_uninstall_hook() {
+  delete_state=0
+  remove_data=0
+${manifest.uninstall?.state ? wizardFlag("delete_state", ["pkgwizard_delete_state"]) : ""}${wizardFlag("remove_data", ["pkgwizard_remove_additional", "delete_app_data"])}  [ "$delete_state" -eq 0 ] || synopkgland_purge_args=--delete-state
+  hook_dest="\${SYNOPKG_PKGDEST:-/var/packages/${pkg}/target}"
+  hook_var="\${SYNOPKG_PKGVAR:-/var/packages/${pkg}/var}"
+  mkdir -p "$hook_var/tmp" 2>/dev/null || true
+  # Its own process group, so a timeout stops the hook's children too; its
+  # output goes to a file, so a lingering child cannot hold DSM's pipe open.
+  set -m
+  (cd "$hook_var" 2>/dev/null || cd /; exec /usr/bin/env -i ${env} ${argv}) </dev/null >"$hook_var/uninstall-hook.log" 2>&1 &
+  hook_pid=$!
+  set +m
+  hook_waited=0
+  while kill -0 "$hook_pid" 2>/dev/null && [ "$hook_waited" -lt ${purge.timeout} ]; do
+    sleep 1
+    hook_waited=$((hook_waited + 1))
+  done
+  hook_failure=
+  if kill -0 "$hook_pid" 2>/dev/null; then
+    kill -TERM -"$hook_pid" 2>/dev/null || kill -TERM "$hook_pid" 2>/dev/null
+    sleep 1
+    kill -KILL -"$hook_pid" 2>/dev/null || kill -KILL "$hook_pid" 2>/dev/null
+    wait "$hook_pid" 2>/dev/null
+    hook_failure="timeout after ${purge.timeout} s"
+  else
+    wait "$hook_pid"
+    hook_status=$?
+    [ "$hook_status" -eq 0 ] || hook_failure="exit $hook_status"
+  fi
+  if [ -n "$hook_failure" ]; then
+    echo "${logged}" >&2
+    logger -t ${UNINSTALL_SYSLOG_TAG} "${logged}" 2>/dev/null || true
+  fi
+  return 0
+}
+`;
+}

package/dist/standalone/uninstall.d.ts

@@ -0,0 +1,53 @@
+import { type Catalog, type Catalogs, type Locale } from "./i18n.js";
+import type { StandaloneError } from "./manifest.js";
+import { type RootOp } from "./root-ops.js";
+/**
+ * `uninstall`: the App's own hook on a real uninstall, run as the package
+ * account before the executor purge, and the state it deletes when the
+ * administrator ticks the uninstall wizard's "delete state" box.
+ */
+export interface Uninstall {
+    purge: UninstallPurge;
+    state?: {
+        items: Array<{
+            key: string;
+        }>;
+    };
+}
+export interface UninstallPurge {
+    /** A package-relative executable, outside executor/ and root/. */
+    exec: string;
+    args: string[];
+    env: Record<string, string>;
+    /** Seconds, 2..120. */
+    timeout: number;
+    /** A root/<name>.sh the executor runs at uninstall, only while its approval is live. */
+    root?: string;
+}
+/** The two flags the generated preuninst hands the hook. */
+export declare const UNINSTALL_FLAGS: readonly ["SYNOPKGLAND_DELETE_STATE", "SYNOPKGLAND_REMOVE_DATA"];
+export interface UninstallContext {
+    rootOps: boolean;
+    ops?: RootOp[];
+    /** The App's English catalog; each state item needs `uninstall.state.<key>`. */
+    en?: Catalog;
+}
+export declare function stateTextKey(key: string): string;
+export declare function readUninstall(value: unknown, context: UninstallContext, fail: (error: StandaloneError) => void): Uninstall | undefined;
+/** The hook in the staged package: a regular executable that does not try to become root. */
+export declare function uninstallExecProblem(packageDir: string, purge: UninstallPurge): StandaloneError | undefined;
+/** Each state item's text in this locale's catalog, English when the App does not ship it. */
+export declare function stateItemTexts(uninstall: Uninstall, catalogs: Catalogs | undefined, locale: Locale): string[];
+/**
+ * sdk-package.json's `uninstall`: the hook and the state item texts per
+ * locale, from which inspect renders the same preuninst and wizard again.
+ */
+export interface UninstallRecord extends Uninstall {
+    texts?: Catalogs;
+}
+export declare function uninstallRecord(uninstall: Uninstall, catalogs: Catalogs | undefined): UninstallRecord;
+/** The record read back and checked as the manifest's `uninstall` is; undefined when it does not hold. */
+export declare function readUninstallRecord(value: unknown, rootOps: boolean): {
+    uninstall: Uninstall;
+    catalogs?: Catalogs;
+} | undefined;

package/dist/standalone/uninstall.js

@@ -0,0 +1,136 @@
+import { lstatSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { LOCALES } from "./i18n.js";
+import { ROOT_SCRIPT_HINTS } from "./root-ops.js";
+import { envKey, relativeExec, token } from "./daemon.js";
+/** The two flags the generated preuninst hands the hook. */
+export const UNINSTALL_FLAGS = ["SYNOPKGLAND_DELETE_STATE", "SYNOPKGLAND_REMOVE_DATA"];
+const FIELDS = new Set(["purge", "state"]);
+const PURGE_FIELDS = new Set(["exec", "args", "env", "timeout", "root"]);
+const STATE_KEY = /^[a-z][A-Za-z0-9_-]{0,31}$/;
+const record = (v) => Boolean(v) && typeof v === "object" && !Array.isArray(v);
+export function stateTextKey(key) {
+    return `uninstall.state.${key}`;
+}
+export function readUninstall(value, context, fail) {
+    if (value === undefined)
+        return undefined;
+    const invalid = () => {
+        fail({ code: "UNINSTALL_INVALID", message: "uninstall 只接受 purge {exec, args, env, timeout, root} 與 state {items: [{key}]}；exec 須是套件內固定執行檔（不可在 executor/ 或 root/），timeout 為 2–120 秒整數。" });
+        return undefined;
+    };
+    if (!record(value) || Object.keys(value).some(k => !FIELDS.has(k)))
+        return invalid();
+    if (value.purge === undefined) {
+        if (value.state === undefined)
+            return invalid();
+        fail({ code: "UNINSTALL_STATE_REQUIRES_PURGE", message: "uninstall.state 需要 uninstall.purge：只有 App 自己知道狀態存在哪裡。" });
+        return undefined;
+    }
+    const purge = readPurge(value.purge, context, fail);
+    if (purge === "invalid")
+        return invalid();
+    const state = value.state === undefined ? undefined : readState(value.state);
+    if (state === "invalid")
+        return invalid();
+    const missing = (state?.items ?? []).map(item => stateTextKey(item.key)).filter(key => context.en?.[key] === undefined);
+    if (missing.length) {
+        fail({ code: "UNINSTALL_STATE_TEXT_MISSING", message: `uninstall.state 的項目需要 i18n en.json 文字：${missing.join(", ")}。` });
+        return undefined;
+    }
+    return purge && { purge, ...(state ? { state } : {}) };
+}
+function readPurge(value, context, fail) {
+    if (!record(value) || Object.keys(value).some(k => !PURGE_FIELDS.has(k)))
+        return "invalid";
+    const top = typeof value.exec === "string" ? value.exec.split("/")[0] : "";
+    if (!relativeExec(value.exec) || top === "executor" || top === "root")
+        return "invalid";
+    const args = value.args ?? [];
+    if (!Array.isArray(args) || args.length > 64 || !args.every(token))
+        return "invalid";
+    const env = value.env ?? {};
+    if (!record(env) || Object.keys(env).length > 64
+        || Object.entries(env).some(([k, v]) => !envKey(k) || k.startsWith("SYNOPKGLAND_") || !token(v)))
+        return "invalid";
+    const timeout = value.timeout ?? 60;
+    if (!Number.isInteger(timeout) || timeout < 2 || timeout > 120)
+        return "invalid";
+    const root = value.root;
+    if (root !== undefined) {
+        if (typeof root !== "string")
+            return "invalid";
+        if (!context.rootOps) {
+            fail({ code: "UNINSTALL_ROOT_REQUIRES_ROOT_OPS", message: "uninstall.purge.root 需要 capabilities.rootOps: true。" });
+            return undefined;
+        }
+        if (context.ops && !context.ops.some(op => op.name === root)) {
+            fail({ code: "UNINSTALL_ROOT_OP_MISSING", message: `uninstall.purge.root「${root}」需要 root/${root}.sh。` });
+            return undefined;
+        }
+    }
+    return {
+        exec: value.exec,
+        args: args,
+        env: Object.fromEntries(Object.keys(env).sort().map(key => [key, env[key]])),
+        timeout: timeout,
+        ...(root === undefined ? {} : { root }),
+    };
+}
+function readState(value) {
+    if (!record(value) || Object.keys(value).some(k => k !== "items") || !Array.isArray(value.items))
+        return "invalid";
+    const items = value.items;
+    if (items.length === 0 || items.length > 16)
+        return "invalid";
+    const keys = items.map(item => record(item) && Object.keys(item).length === 1 && typeof item.key === "string" && STATE_KEY.test(item.key) ? item.key : undefined);
+    if (keys.some(key => key === undefined) || new Set(keys).size !== keys.length)
+        return "invalid";
+    return { items: keys.map(key => ({ key: key })) };
+}
+/** The hook in the staged package: a regular executable that does not try to become root. */
+export function uninstallExecProblem(packageDir, purge) {
+    const path = join(packageDir, purge.exec);
+    let stat;
+    try {
+        stat = lstatSync(path);
+    }
+    catch {
+        stat = undefined;
+    }
+    if (!stat?.isFile() || (stat.mode & 0o111) === 0) {
+        return { code: "UNINSTALL_EXEC_MISSING", message: `uninstall.purge.exec「${purge.exec}」不是套件內可執行的一般檔案。` };
+    }
+    const text = readFileSync(path).toString("latin1");
+    if (text.startsWith("#!") && ROOT_SCRIPT_HINTS.some(hint => hint.test(text))) {
+        return { code: "UNINSTALL_EXEC_UNSAFE", message: `uninstall.purge.exec「${purge.exec}」嘗試取得 root（sudo、chown root 或 setuid）；root 只能經 uninstall.purge.root。` };
+    }
+    return undefined;
+}
+/** Each state item's text in this locale's catalog, English when the App does not ship it. */
+export function stateItemTexts(uninstall, catalogs, locale) {
+    return (uninstall.state?.items ?? []).map(({ key }) => catalogs?.[locale]?.[stateTextKey(key)] ?? catalogs?.en[stateTextKey(key)] ?? key);
+}
+export function uninstallRecord(uninstall, catalogs) {
+    if (!uninstall.state)
+        return uninstall;
+    const keys = uninstall.state.items.map(item => stateTextKey(item.key));
+    const texts = Object.fromEntries(LOCALES.flatMap(locale => {
+        const catalog = catalogs?.[locale];
+        const found = Object.fromEntries(keys.filter(key => catalog?.[key] !== undefined).map(key => [key, catalog[key]]));
+        return Object.keys(found).length ? [[locale, found]] : [];
+    }));
+    return { ...uninstall, texts: texts };
+}
+/** The record read back and checked as the manifest's `uninstall` is; undefined when it does not hold. */
+export function readUninstallRecord(value, rootOps) {
+    if (!record(value))
+        return undefined;
+    const { texts, ...rest } = value;
+    if (texts !== undefined && (!record(texts) || Object.entries(texts).some(([locale, catalog]) => !LOCALES.includes(locale) || !record(catalog) || Object.values(catalog).some(text => typeof text !== "string"))))
+        return undefined;
+    let failed = false;
+    const catalogs = texts;
+    const uninstall = readUninstall(rest, { rootOps, en: catalogs?.en }, () => { failed = true; });
+    return uninstall && !failed ? { uninstall, ...(catalogs ? { catalogs } : {}) } : undefined;
+}

package/dist/types.d.ts

@@ -56,4 +56,4 @@ export interface ComposeDocument {
     secrets?: Record<string, unknown>;
     [key: string]: unknown;
 }
-export type TemplateName = "compose" | "binary" | "native-go";
+export type TemplateName = "compose" | "binary" | "native-go" | "native-rust";

package/dist/yaml-edit.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sets top-level keys of a YAML mapping in its source text: each named key's
+ * entry is rewritten, a missing one is appended, and every other line,
+ * comments and formatting included, stays as written.
+ */
+export declare function setTopLevel(text: string, values: Record<string, unknown>): string;

package/dist/yaml-edit.js

@@ -0,0 +1,31 @@
+import { isMap, isScalar, parseDocument, stringify } from "yaml";
+/**
+ * Sets top-level keys of a YAML mapping in its source text: each named key's
+ * entry is rewritten, a missing one is appended, and every other line,
+ * comments and formatting included, stays as written.
+ */
+export function setTopLevel(text, values) {
+    const doc = parseDocument(text);
+    if (!isMap(doc.contents))
+        throw new Error("YAML document is not a mapping.");
+    const edits = [];
+    let appended = "";
+    for (const [key, value] of Object.entries(values)) {
+        const rendered = stringify({ [key]: value });
+        const pair = doc.contents.items.find(item => isScalar(item.key) && item.key.value === key);
+        const start = isScalar(pair?.key) ? pair.key.range?.[0] : undefined;
+        const end = pair?.value?.range?.[1];
+        if (start === undefined || end === undefined) {
+            appended += rendered;
+            continue;
+        }
+        // A block value ends after its last line's newline; a flow or plain value before it.
+        edits.push({ start, end, text: text[end - 1] === "\n" ? rendered : rendered.replace(/\n$/, "") });
+    }
+    let out = text;
+    for (const edit of edits.sort((a, b) => b.start - a.start))
+        out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+    if (!appended)
+        return out;
+    return `${out}${out === "" || out.endsWith("\n") ? "" : "\n"}${appended}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synopackageland/cli",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Syno Package Land Developer Kit CLI",
   "type": "module",
   "bin": {
@@ -24,7 +24,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@synopackageland/templates": "0.9.4",
+    "@synopackageland/templates": "0.9.6",
     "ajv": "^8.17.1",
     "commander": "^13.1.0",
     "tar": "^7.4.3",

package/skills/reference/portal.md

@@ -2,20 +2,24 @@
 
 Tier: only an App with the executor (`capabilities.rootOps` or `capabilities.delegate`) may declare a portal, because after uninstall only root can make nginx stop serving the alias. A no-privilege native App fails check/build with `STANDALONE_PORTAL_REQUIRES_EXECUTOR`, `add portal` refuses it unless the same call adds `root-ops` or `delegate`, and inspect flags such an SPK with `PORTAL_REQUIRES_EXECUTOR`. A Compose App has no executor: `integration.web.portal` always fails with `CONTRACT_PORTAL_REQUIRES_EXECUTOR`. Without the executor, an administrator can set up a reverse proxy in DSM instead.
 
-Declare: native-go/binary with rootOps or delegate, `portal: {}` or `portal: {alias: my-app}` in dsm-package.yaml (`synopkgland add root-ops portal`, or `add portal` once the executor is declared). The alias defaults to the package name in lowercase. Aliases are 1–64 lowercase letters, digits or `-`, not starting or ending with `-`, and not a DSM path or Synology App alias (`webman`, `file`, …). The native-layout `backend: {kind: native}` owns its conf/scripts: the SDK does not register a portal for it.
+Declare: native-go/binary with rootOps or delegate, `portal: {}` or `portal: {alias: my-app}` in dsm-package.yaml (`synopkgland add root-ops portal`, or `add portal` once the executor is declared). The alias defaults to the package name in lowercase. Aliases are 1–64 lowercase letters, digits or `-`, not starting or ending with `-`, and not a DSM path or Synology App alias (`webman`, `file`, …). The native-layout `backend: {kind: native}` owns its conf/scripts and its own root helper: `portal: {}` or `{alias}` there needs os_min_ver 7.1-42661+ and writes only `synopkgland_portal_alias="<alias>"` into INFO, which Package Center writes as root, so the product's root helper can trust it; the helper registers the app.d entry (application = INFO displayname) and owns its uninstall cleanup and wizard. inspect checks that INFO line against `native-layout.json`.
 
-Build: the SPK carries `etc/portal.json` (every field DSM's app-portal worker needs) and `etc/portal.mustache`, `conf/resource` registers them, and the install wizard adds a prefilled alias step. preinst validates the answer; postinst stores it as the package's own draft and default alias. Nothing is active until an administrator applies it. `inspect <spk> --json` reports `portal: {appId, alias}` and refuses any other portal content.
+Build (os_min_ver 7.2-64570+): the SPK carries `etc/portal.json` (every field DSM's app-portal worker needs) and `etc/portal.mustache`, `conf/resource` registers them, and the install wizard adds a prefilled alias step. preinst validates the answer; postinst stores it as the package's own draft and default alias. Nothing is active until an administrator applies it. `inspect <spk> --json` reports `portal: {appId, alias}` and refuses any other portal content.
 
 Activate: DSM owns the saved setting. Administrators use the app's portal panel (`ctx.portal.apply(alias)` / `disable()`, DSM `SYNO.Core.AppPortal set` with their own session; DSM refuses non-administrators with 105) or Control Panel > Login Portal > Applications (`ctx.portal.openControlPanel()`). DSM errors map to `portal_alias_invalid`, `portal_alias_reserved`, `portal_alias_in_use`, `admin_required`, `portal_unavailable`.
 
 Read: ordinary users call the Go backend's `portal.status` (`authenticated`), which reads `/var/packages/<package>/etc/AppPortal.json` read-only, bounded (64 KiB, no symlinks, one JSON object, matching app id). Anything else is `unavailable` and the UI shows "ask an administrator". A binary CGI must implement the same `{state, alias}` answer itself or ordinary users never see the link.
 
-DSM floor: os_min_ver must be 7.3.2-86009 or later. DSM 7.1.1-42962 refuses an unsigned SPK whose conf/resource carries web-config app-portal (Package Center error 320, "non-synology-signed package should not use internal worker"); 7.3.2-86009 and 7.4 install it; 7.2 and 7.3.0/7.3.1 are untested (unknown). validate/build fail with `STANDALONE_PORTAL_MIN_DSM`, `--min-dsm` cannot go below it, `add portal` raises a lower os_min_ver, and inspect flags a lower INFO os_min_ver. Fix: raise os_min_ver or remove the portal.
+Executor mode (7.1-42661 ≤ os_min_ver < 7.2-64570): no web-config resource, no `etc/portal.*`, no alias wizard step or alias lifecycle. The executor policy carries `portal: {application: <displayname>, alias}` and the operations `portal.register` and `portal.unregister`; the executor writes `/usr/syno/etc/www/app.d/<package>.{json,mustache}`. The package name must match `^[A-Za-z0-9]+(?:[._-][A-Za-z0-9]+)*$` (≤ 64) and displayname be 1–64 characters without control characters, or build fails with `STANDALONE_PORTAL_ENTRY_INVALID`. The CGI is built with `-X main.portal=executor`: `portal.status` adds `entry` (`registered`, `unregistered`, `cleanup-required`; an unreadable executor is `unavailable`), and `portal.register` / `portal.unregister` take the administrator's DSM session and return the fresh status. `ctx.portal.register()` / `unregister()` call them; the plain panel shows text and "Enable entry" while unregistered, the alias form and "Remove entry" once registered, text and "Remove entry" when cleanup is required, and no entry buttons for non-administrators. Executor refusals keep their code (`PORTAL_FAILED`). Needs templates with the executor portal routes (after 0.9.4) and an SDK with the `portal` entry API (after 0.9.5).
+
+DSM floor: os_min_ver must be 7.1-42661 or later; below 7.2-64570 the executor registers the entry (above). DSM 7.1 marks the web-config worker Synology-only, so it refuses an unsigned SPK whose conf/resource carries web-config (Package Center error 320, "non-synology-signed package should not use internal worker"; seen on 7.1.1-42962). synopkg from DSM 7.2 on drops that mark, the only change to its worker table; the 7.2 floor comes from that source and is not yet verified on a 7.2 NAS. 7.3.2-86009 and 7.4 install it. Below 7.1 validate/build fail with `STANDALONE_PORTAL_MIN_DSM`, `--min-dsm` cannot go below 7.1, `add portal` raises a lower os_min_ver to 7.1-42661, and inspect flags an INFO os_min_ver below the floor of the SPK's mode. Fix: raise os_min_ver or remove the portal.
 
 Capability: beyond that floor, no version gate. The panel needs SYNO.API.Info to list `SYNO.Core.AppPortal` (v2) and the app's registration to exist; otherwise administrators get only the Control Panel shortcut.
 
 UI: plain JS calls `ctx.portal && ctx.portal.mountPanel(element)` and disposes it on unmount; Vue renders `portal/PortalSettings.vue`. `ctx.portal.messages` carries the SDK text in all nine languages.
 
-Never: write `AppPortal.json`, `@appconf/<package>` or `/usr/syno/etc/www/app.d`; add a backend route that changes the alias; relay QuickConnect responses or build QuickConnect links; reboot or change other packages' portal entries while testing. DSM keeps the alias across upgrades and removes the entry on uninstall, but it does not reload nginx, and it keeps the App's Application Privileges rules.
+Never: write `AppPortal.json`, `@appconf/<package>` or `/usr/syno/etc/www/app.d` from the App (only the executor's approved `portal.*` operations write app.d); add a backend route that changes the alias; relay QuickConnect responses or build QuickConnect links; reboot or change other packages' portal entries while testing. DSM keeps the alias across upgrades and removes the entry on uninstall, but it does not reload nginx, and it keeps the App's Application Privileges rules.
 
 Uninstall: the root executor's purge deletes the rules of `SYNO.SDS.<package>.Instance` through the Application Privileges API and, once DSM has removed the alias files, reloads nginx (`synosystemctl reload nginx`), so the alias stops at once. Failures are only logged to the system log entry `synopkgland-executor`; then an administrator saves an alias in Control Panel > Login Portal > Applications (which reloads nginx) or restarts the NAS, and removes the rules in Control Panel > Application Privileges. The uninstall wizard and the `status`/`inspect` cleanup list say this in that order: automatic first, manual only as the fallback.
+
+Executor mode uninstall: the purge reads the retained policy and unregisters the entry. If the executor is not running or was never approved, uninstall does not remove the entry; the wizard and cleanup list say so and give the root commands (`rm -f /usr/syno/etc/www/app.d/<package>.json /usr/syno/etc/www/app.d/<package>.mustache /usr/syno/etc/packages/<package>/AppPortal.json`, `synow3tool --disable-nginx-confd/--unreg-nginx-confd` for `dsm www alias .alias`, `--disable-nginx-sites/--unreg-nginx-sites` for `server .server` on `<c>.syno-app-portal.<package>.conf`, then `nginx -t && synow3tool --nginx=reload`).