@synopackageland/cli 0.3.10 → 0.4.1

package/dist/standalone/root-messages.js

@@ -0,0 +1,259 @@
+/**
+ * Text of the authorization panel every privilege: root package shows, the
+ * same in every package. DSM's own words (Task Scheduler, Run, Remove, …) are
+ * taken verbatim from DSM 7.4; test/standalone-root-messages.test.ts pins them.
+ */
+export const ROOT_MESSAGES = {
+    en: {
+        title: "Administrator authorization",
+        intro: "This package can run the fixed operation \"{op}\" as root. A DSM administrator approves it once with their password. DSM then keeps it as a disabled task in Task Scheduler that runs only when an administrator clicks Run here.",
+        status: "Status",
+        last_run: "Last run time",
+        never: "Not run yet",
+        output: "Result",
+        "state.checking": "Loading...",
+        "state.missing": "Not authorized",
+        "state.ready": "Authorized",
+        "state.outdated": "The package was updated and needs authorization again",
+        "state.conflict": "Another Task Scheduler task already uses the name \"{name}\"",
+        authorize: "Authorize",
+        run: "Run",
+        remove: "Remove",
+        retry: "Retry",
+        completed: "Completed",
+        cancelled: "Authorization was cancelled. Nothing was created.",
+        admin_only: "Only administrator accounts can perform this operation.",
+        uninstall_hint: "Before uninstalling this package, click Remove to delete its task from Task Scheduler.",
+        "error.root_conflict": "Rename or delete the task \"{name}\" in Task Scheduler, then click Retry.",
+        "error.root_cancelled": "Password confirmation was cancelled. No operation was run.",
+        "error.root_not_ready": "Authorize this operation first.",
+        "error.root_task_failed": "The task ended with an error. Check its history in Task Scheduler, then click Retry.",
+        "error.root_timeout": "The task did not finish in time. Check it in Task Scheduler, then click Retry.",
+        "error.root_verify_failed": "Task Scheduler does not show the expected task. Click Retry.",
+        "error.default": "The operation failed ({code}). Click Retry.",
+    },
+    "zh-TW": {
+        title: "管理員授權",
+        intro: "此套件可用 root 身分執行固定操作「{op}」。DSM 管理員以密碼核准一次後，DSM 會在任務排程表中保留一個已停用的任務，只有管理員在此按下「執行」時才會執行。",
+        status: "狀態",
+        last_run: "最後執行時間",
+        never: "尚未執行",
+        output: "結果",
+        "state.checking": "載入中...",
+        "state.missing": "未授權",
+        "state.ready": "已授權",
+        "state.outdated": "套件已更新，需要重新授權",
+        "state.conflict": "任務排程表中已有其他任務使用名稱「{name}」",
+        authorize: "授權",
+        run: "執行",
+        remove: "移除",
+        retry: "重試",
+        completed: "已完成",
+        cancelled: "已取消授權，未建立任何任務。",
+        admin_only: "僅限管理員帳號允許執行此操作。",
+        uninstall_hint: "解除安裝此套件前，請按「移除」從任務排程表刪除它的任務。",
+        "error.root_conflict": "請在任務排程表中重新命名或刪除任務「{name}」，再按「重試」。",
+        "error.root_cancelled": "已取消密碼確認，未執行任何操作。",
+        "error.root_not_ready": "請先授權此操作。",
+        "error.root_task_failed": "任務執行失敗。請在任務排程表查看其記錄，再按「重試」。",
+        "error.root_timeout": "任務未在時限內完成。請在任務排程表確認後，再按「重試」。",
+        "error.root_verify_failed": "任務排程表中沒有預期的任務。請按「重試」。",
+        "error.default": "操作失敗（{code}）。請按「重試」。",
+    },
+    "zh-CN": {
+        title: "管理员授权",
+        intro: "此套件可以 root 身份运行固定操作“{op}”。DSM 管理员用密码批准一次后，DSM 会在任务计划中保留一个已禁用的任务，只有管理员在此单击“运行”时才会运行。",
+        status: "状态",
+        last_run: "最后运行时间",
+        never: "尚未运行",
+        output: "结果",
+        "state.checking": "加载中...",
+        "state.missing": "未授权",
+        "state.ready": "已授权",
+        "state.outdated": "套件已更新，需要重新授权",
+        "state.conflict": "任务计划中已有其他任务使用名称“{name}”",
+        authorize: "授权",
+        run: "运行",
+        remove: "删除",
+        retry: "重试",
+        completed: "已完成",
+        cancelled: "已取消授权，未创建任何任务。",
+        admin_only: "只有管理员帐户才能执行此操作。",
+        uninstall_hint: "卸载此套件前，请单击“删除”从任务计划中删除它的任务。",
+        "error.root_conflict": "请在任务计划中重命名或删除任务“{name}”，然后单击“重试”。",
+        "error.root_cancelled": "已取消密码确认，未执行任何操作。",
+        "error.root_not_ready": "请先授权此操作。",
+        "error.root_task_failed": "任务运行失败。请在任务计划中查看其记录，然后单击“重试”。",
+        "error.root_timeout": "任务未在时限内完成。请在任务计划中确认后单击“重试”。",
+        "error.root_verify_failed": "任务计划中没有预期的任务。请单击“重试”。",
+        "error.default": "操作失败（{code}）。请单击“重试”。",
+    },
+    ja: {
+        title: "管理者の承認",
+        intro: "このパッケージは固定の操作「{op}」を root として実行できます。DSM 管理者がパスワードで一度承認すると、DSM はタスク スケジューラーに無効のタスクとして保持し、管理者がここで「実行」をクリックしたときだけ実行します。",
+        status: "状態",
+        last_run: "最終実行時刻",
+        never: "まだ実行されていません",
+        output: "結果",
+        "state.checking": "読み込み中...",
+        "state.missing": "未承認",
+        "state.ready": "承認済み",
+        "state.outdated": "パッケージが更新されたため、再承認が必要です",
+        "state.conflict": "タスク スケジューラーの別のタスクが名前「{name}」を使用しています",
+        authorize: "承認",
+        run: "実行",
+        remove: "削除",
+        retry: "再試行",
+        completed: "完了",
+        cancelled: "承認はキャンセルされました。何も作成されていません。",
+        admin_only: "この操作を実行できるのは管理者アカウントのみです。",
+        uninstall_hint: "このパッケージをアンインストールする前に、「削除」をクリックしてタスク スケジューラーからタスクを削除してください。",
+        "error.root_conflict": "タスク スケジューラーでタスク「{name}」の名前を変更するか削除してから、「再試行」をクリックしてください。",
+        "error.root_cancelled": "パスワードの確認がキャンセルされました。操作は実行されていません。",
+        "error.root_not_ready": "先にこの操作を承認してください。",
+        "error.root_task_failed": "タスクがエラーで終了しました。タスク スケジューラーで履歴を確認してから、「再試行」をクリックしてください。",
+        "error.root_timeout": "タスクが時間内に完了しませんでした。タスク スケジューラーで確認してから、「再試行」をクリックしてください。",
+        "error.root_verify_failed": "タスク スケジューラーに想定したタスクが見つかりません。「再試行」をクリックしてください。",
+        "error.default": "操作に失敗しました ({code})。「再試行」をクリックしてください。",
+    },
+    ko: {
+        title: "관리자 승인",
+        intro: "이 패키지는 고정된 작업 \"{op}\"을(를) root로 실행할 수 있습니다. DSM 관리자가 암호로 한 번 승인하면 DSM이 작업 스케줄러에 비활성화된 작업으로 보관하며, 관리자가 여기에서 \"실행\"을 클릭할 때만 실행됩니다.",
+        status: "상태",
+        last_run: "마지막 실행 시간",
+        never: "아직 실행되지 않음",
+        output: "결과",
+        "state.checking": "로드 중…",
+        "state.missing": "승인되지 않음",
+        "state.ready": "승인됨",
+        "state.outdated": "패키지가 업데이트되어 다시 승인해야 합니다",
+        "state.conflict": "작업 스케줄러의 다른 작업이 이미 \"{name}\" 이름을 사용하고 있습니다",
+        authorize: "승인",
+        run: "실행",
+        remove: "제거",
+        retry: "재시도",
+        completed: "완료됨",
+        cancelled: "승인이 취소되었습니다. 아무것도 만들어지지 않았습니다.",
+        admin_only: "관리자 계정에서만 이 작업을 수행할 수 있습니다.",
+        uninstall_hint: "이 패키지를 제거하기 전에 \"제거\"를 클릭하여 작업 스케줄러에서 작업을 삭제하십시오.",
+        "error.root_conflict": "작업 스케줄러에서 작업 \"{name}\"의 이름을 바꾸거나 삭제한 후 \"재시도\"를 클릭하십시오.",
+        "error.root_cancelled": "비밀번호 확인이 취소되었습니다. 작업이 실행되지 않았습니다.",
+        "error.root_not_ready": "먼저 이 작업을 승인하십시오.",
+        "error.root_task_failed": "작업이 오류로 종료되었습니다. 작업 스케줄러에서 기록을 확인한 후 \"재시도\"를 클릭하십시오.",
+        "error.root_timeout": "작업이 제시간에 완료되지 않았습니다. 작업 스케줄러에서 확인한 후 \"재시도\"를 클릭하십시오.",
+        "error.root_verify_failed": "작업 스케줄러에 예상한 작업이 없습니다. \"재시도\"를 클릭하십시오.",
+        "error.default": "작업에 실패했습니다({code}). \"재시도\"를 클릭하십시오.",
+    },
+    de: {
+        title: "Administratorfreigabe",
+        intro: "Dieses Paket kann den festen Vorgang „{op}“ als root ausführen. Ein DSM-Administrator genehmigt ihn einmal mit seinem Passwort. DSM behält ihn dann als deaktivierte Aufgabe im Aufgabenplaner, die nur ausgeführt wird, wenn ein Administrator hier auf „Ausführen“ klickt.",
+        status: "Status",
+        last_run: "Letzte Ausführungszeit",
+        never: "Noch nicht ausgeführt",
+        output: "Ergebnis",
+        "state.checking": "Wird geladen...",
+        "state.missing": "Nicht freigegeben",
+        "state.ready": "Freigegeben",
+        "state.outdated": "Das Paket wurde aktualisiert und muss erneut freigegeben werden",
+        "state.conflict": "Eine andere Aufgabe im Aufgabenplaner verwendet bereits den Namen „{name}“",
+        authorize: "Freigeben",
+        run: "Ausführen",
+        remove: "Entfernen",
+        retry: "Neuer Versuch",
+        completed: "Abgeschlossen",
+        cancelled: "Die Freigabe wurde abgebrochen. Es wurde nichts erstellt.",
+        admin_only: "Nur Administratorkonten können diesen Vorgang ausführen.",
+        uninstall_hint: "Klicken Sie vor der Deinstallation dieses Pakets auf „Entfernen“, um seine Aufgabe aus dem Aufgabenplaner zu löschen.",
+        "error.root_conflict": "Benennen Sie die Aufgabe „{name}“ im Aufgabenplaner um oder löschen Sie sie, und klicken Sie dann auf „Neuer Versuch“.",
+        "error.root_cancelled": "Die Passwortbestätigung wurde abgebrochen. Es wurde keine Aktion ausgeführt.",
+        "error.root_not_ready": "Geben Sie diesen Vorgang zuerst frei.",
+        "error.root_task_failed": "Die Aufgabe wurde mit einem Fehler beendet. Prüfen Sie ihren Verlauf im Aufgabenplaner, und klicken Sie dann auf „Neuer Versuch“.",
+        "error.root_timeout": "Die Aufgabe wurde nicht rechtzeitig beendet. Prüfen Sie sie im Aufgabenplaner, und klicken Sie dann auf „Neuer Versuch“.",
+        "error.root_verify_failed": "Der Aufgabenplaner zeigt die erwartete Aufgabe nicht. Klicken Sie auf „Neuer Versuch“.",
+        "error.default": "Der Vorgang ist fehlgeschlagen ({code}). Klicken Sie auf „Neuer Versuch“.",
+    },
+    fr: {
+        title: "Autorisation de l'administrateur",
+        intro: "Ce paquet peut exécuter l'opération fixe « {op} » en tant que root. Un administrateur DSM l'approuve une fois avec son mot de passe. DSM la conserve ensuite comme tâche désactivée dans le Planificateur de tâches, qui ne s'exécute que lorsqu'un administrateur clique ici sur « Exécuter ».",
+        status: "Statut",
+        last_run: "Dernière heure d'exécution",
+        never: "Pas encore exécutée",
+        output: "Résultat",
+        "state.checking": "Chargement...",
+        "state.missing": "Non autorisée",
+        "state.ready": "Autorisée",
+        "state.outdated": "Le paquet a été mis à jour et doit être autorisé de nouveau",
+        "state.conflict": "Une autre tâche du Planificateur de tâches utilise déjà le nom « {name} »",
+        authorize: "Autoriser",
+        run: "Exécuter",
+        remove: "Supprimer",
+        retry: "Réessayer",
+        completed: "Terminé",
+        cancelled: "L'autorisation a été annulée. Rien n'a été créé.",
+        admin_only: "Seuls les comptes administrateur peuvent effectuer cette opération.",
+        uninstall_hint: "Avant de désinstaller ce paquet, cliquez sur « Supprimer » pour retirer sa tâche du Planificateur de tâches.",
+        "error.root_conflict": "Renommez ou supprimez la tâche « {name} » dans le Planificateur de tâches, puis cliquez sur « Réessayer ».",
+        "error.root_cancelled": "La confirmation du mot de passe a été annulée. Aucune opération n’a été exécutée.",
+        "error.root_not_ready": "Autorisez d'abord cette opération.",
+        "error.root_task_failed": "La tâche s'est terminée avec une erreur. Consultez son historique dans le Planificateur de tâches, puis cliquez sur « Réessayer ».",
+        "error.root_timeout": "La tâche ne s'est pas terminée à temps. Vérifiez-la dans le Planificateur de tâches, puis cliquez sur « Réessayer ».",
+        "error.root_verify_failed": "Le Planificateur de tâches n'affiche pas la tâche attendue. Cliquez sur « Réessayer ».",
+        "error.default": "L'opération a échoué ({code}). Cliquez sur « Réessayer ».",
+    },
+    es: {
+        title: "Autorización del administrador",
+        intro: "Este paquete puede ejecutar la operación fija «{op}» como root. Un administrador de DSM la aprueba una vez con su contraseña. Después, DSM la conserva como una tarea desactivada en el Programador de tareas que solo se ejecuta cuando un administrador hace clic aquí en «Ejecutar».",
+        status: "Estado",
+        last_run: "Hora de la última ejecución",
+        never: "Aún no se ha ejecutado",
+        output: "Resultado",
+        "state.checking": "Cargando...",
+        "state.missing": "No autorizada",
+        "state.ready": "Autorizada",
+        "state.outdated": "El paquete se actualizó y debe autorizarse de nuevo",
+        "state.conflict": "Otra tarea del Programador de tareas ya usa el nombre «{name}»",
+        authorize: "Autorizar",
+        run: "Ejecutar",
+        remove: "Quitar",
+        retry: "Volver a intentar",
+        completed: "Finalizado",
+        cancelled: "Se canceló la autorización. No se creó nada.",
+        admin_only: "Solo las cuentas de administrador pueden realizar esta operación.",
+        uninstall_hint: "Antes de desinstalar este paquete, haga clic en «Quitar» para eliminar su tarea del Programador de tareas.",
+        "error.root_conflict": "Cambie el nombre de la tarea «{name}» o elimínela en el Programador de tareas y, a continuación, haga clic en «Volver a intentar».",
+        "error.root_cancelled": "Se canceló la confirmación de la contraseña. No se ejecutó ninguna operación.",
+        "error.root_not_ready": "Primero autorice esta operación.",
+        "error.root_task_failed": "La tarea terminó con un error. Consulte su historial en el Programador de tareas y, a continuación, haga clic en «Volver a intentar».",
+        "error.root_timeout": "La tarea no terminó a tiempo. Revísela en el Programador de tareas y, a continuación, haga clic en «Volver a intentar».",
+        "error.root_verify_failed": "El Programador de tareas no muestra la tarea esperada. Haga clic en «Volver a intentar».",
+        "error.default": "Error en la operación ({code}). Haga clic en «Volver a intentar».",
+    },
+    it: {
+        title: "Autorizzazione dell'amministratore",
+        intro: "Questo pacchetto può eseguire l'operazione fissa \"{op}\" come root. Un amministratore DSM la approva una volta con la propria password. DSM la conserva quindi come attività disattivata in Utilità di pianificazione, che viene eseguita solo quando un amministratore fa clic qui su \"Esegui\".",
+        status: "Stato",
+        last_run: "Ora ultima esecuzione",
+        never: "Non ancora eseguita",
+        output: "Risultato",
+        "state.checking": "Caricamento...",
+        "state.missing": "Non autorizzata",
+        "state.ready": "Autorizzata",
+        "state.outdated": "Il pacchetto è stato aggiornato e deve essere autorizzato di nuovo",
+        "state.conflict": "Un'altra attività in Utilità di pianificazione usa già il nome \"{name}\"",
+        authorize: "Autorizza",
+        run: "Esegui",
+        remove: "Rimuovi",
+        retry: "Riprova",
+        completed: "Completato",
+        cancelled: "Autorizzazione annullata. Non è stato creato nulla.",
+        admin_only: "Solo gli account administrator possono eseguire questa operazione.",
+        uninstall_hint: "Prima di disinstallare questo pacchetto, fare clic su \"Rimuovi\" per eliminare la sua attività da Utilità di pianificazione.",
+        "error.root_conflict": "Rinominare o eliminare l'attività \"{name}\" in Utilità di pianificazione, quindi fare clic su \"Riprova\".",
+        "error.root_cancelled": "La conferma della password è stata annullata. Nessuna operazione è stata eseguita.",
+        "error.root_not_ready": "Autorizzare prima questa operazione.",
+        "error.root_task_failed": "L'attività è terminata con un errore. Controllarne la cronologia in Utilità di pianificazione, quindi fare clic su \"Riprova\".",
+        "error.root_timeout": "L'attività non è terminata in tempo. Controllarla in Utilità di pianificazione, quindi fare clic su \"Riprova\".",
+        "error.root_verify_failed": "Utilità di pianificazione non mostra l'attività prevista. Fare clic su \"Riprova\".",
+        "error.default": "Operazione non riuscita ({code}). Fare clic su \"Riprova\".",
+    },
+};

package/dist/standalone/root-ops.d.ts

@@ -0,0 +1,42 @@
+import type { StandaloneError } from "./manifest.js";
+/**
+ * Root operations of a `privilege: root` Standalone Package. Each
+ * `root/<name>.sh` becomes the fixed script of one disabled DSM Task
+ * Scheduler task owned by root, which a DSM administrator creates through
+ * DSM's own password confirmation and runs on demand. The package itself
+ * never runs as root and nothing it can write is ever executed as root.
+ */
+export interface RootOp {
+    name: string;
+    body: string;
+    /** Internal generator flag for protected helper control output. */
+    protectedOutput?: boolean;
+}
+export type RootOpsResult = {
+    ok: true;
+    ops: RootOp[];
+} | {
+    ok: false;
+    errors: StandaloneError[];
+};
+export declare const ROOT_OPS_DIR = "root";
+export declare const ROOT_OP_END = "SYNOPKGLAND_ROOT_OP_END";
+export declare function rootTaskName(packageId: string, op: string): string;
+/**
+ * The fixed start of an operation's task text. It does not carry the version,
+ * so the window can tell its own outdated task from someone else's.
+ */
+export declare function rootTaskHeader(packageId: string, op: string): string;
+/** Root-owned tmpfs folder the tasks write to; the package account can only read it. */
+export declare function rootOutputDir(packageId: string): string;
+export declare function loadRootOps(dir: string): RootOpsResult;
+/**
+ * The exact text of the DSM task. The body runs from a quoted here-document
+ * (no expansion) and its stdout replaces `<op>.out` in the root-owned run
+ * folder. The package version is part of the text, so every upgrade changes
+ * what the administrator approved and needs approval again.
+ */
+export declare function renderRootTaskScript(manifest: {
+    package: string;
+    spkVersion: string;
+}, op: RootOp): string;

package/dist/standalone/root-ops.js

@@ -0,0 +1,101 @@
+import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export const ROOT_OPS_DIR = "root";
+export const ROOT_OP_END = "SYNOPKGLAND_ROOT_OP_END";
+const MAX_ROOT_OP_BYTES = 16 * 1024;
+const OP_FILE = /^([a-z][a-z0-9_]{0,31})\.sh$/;
+export function rootTaskName(packageId, op) {
+    return `${packageId} root: ${op}`;
+}
+/**
+ * The fixed start of an operation's task text. It does not carry the version,
+ * so the window can tell its own outdated task from someone else's.
+ */
+export function rootTaskHeader(packageId, op) {
+    return `#!/bin/sh\n# synopkgland root operation "${op}" of ${packageId} `;
+}
+/** Root-owned tmpfs folder the tasks write to; the package account can only read it. */
+export function rootOutputDir(packageId) {
+    return `/run/synopkgland-${packageId}`;
+}
+export function loadRootOps(dir) {
+    const names = existsSync(dir) ? readdirSync(dir).sort() : [];
+    if (names.length === 0) {
+        return {
+            ok: false,
+            errors: [{ code: "STANDALONE_ROOT_OPS_MISSING", message: `privilege: root 需要 ${ROOT_OPS_DIR}/<名稱>.sh，至少一個 root 操作。` }],
+        };
+    }
+    const errors = [];
+    const ops = [];
+    for (const file of names) {
+        const op = readRootOp(join(dir, file), file);
+        if ("error" in op) {
+            errors.push({ code: "STANDALONE_ROOT_OP_INVALID", message: `${ROOT_OPS_DIR}/${file}：${op.error}` });
+        }
+        else {
+            ops.push(op);
+        }
+    }
+    return errors.length === 0 ? { ok: true, ops } : { ok: false, errors };
+}
+function readRootOp(path, file) {
+    const name = OP_FILE.exec(file)?.[1];
+    if (!name) {
+        return { error: "檔名必須是小寫英數與底線組成的 <名稱>.sh（最多 32 字元），此資料夾不放其他檔案。" };
+    }
+    const stat = lstatSync(path);
+    if (!stat.isFile()) {
+        return { error: "必須是一般檔案（不可是 symlink 或資料夾）。" };
+    }
+    if (stat.size > MAX_ROOT_OP_BYTES) {
+        return { error: `不可超過 ${MAX_ROOT_OP_BYTES} bytes。` };
+    }
+    const body = readFileSync(path, "utf8");
+    if (!body.startsWith("#!/bin/sh\n") || body.includes("\0") || body.includes("�")) {
+        return { error: "必須是以 #!/bin/sh 開頭的 UTF-8 文字 script。" };
+    }
+    if (body.split("\n").includes(ROOT_OP_END)) {
+        return { error: `不可包含單獨一行的 ${ROOT_OP_END}。` };
+    }
+    return { name, body };
+}
+/**
+ * The exact text of the DSM task. The body runs from a quoted here-document
+ * (no expansion) and its stdout replaces `<op>.out` in the root-owned run
+ * folder. The package version is part of the text, so every upgrade changes
+ * what the administrator approved and needs approval again.
+ */
+export function renderRootTaskScript(manifest, op) {
+    const body = op.body.endsWith("\n") ? op.body : `${op.body}\n`;
+    return `${rootTaskHeader(manifest.package, op.name)}${manifest.spkVersion}.
+# Approved by a DSM administrator; runs only when this task is run.
+set -eu
+umask 022
+PATH=/usr/sbin:/usr/bin:/sbin:/bin
+export PATH
+dir=${rootOutputDir(manifest.package)}
+${op.protectedOutput ? `[ "$(id -u)" = 0 ]
+[ ! -L /run ] && [ "$(stat -c %u /run)" = 0 ]
+[ ! -L "$dir" ]
+if [ ! -e "$dir" ]; then mkdir -m 0755 "$dir"; fi
+[ -d "$dir" ] && [ "$(stat -c %u "$dir")" = 0 ]
+output_mode=$(stat -c %a "$dir")
+[ "$((0$output_mode & 0022))" = 0 ]
+` : `if [ -L "$dir" ] || [ ! -d "$dir" ]; then
+  rm -f "$dir"
+  mkdir -m 0755 "$dir"
+fi
+`}tmp=$(mktemp "$dir/.${op.name}.XXXXXX")
+if /bin/sh -eu >"$tmp" <<'${ROOT_OP_END}'
+${body}${ROOT_OP_END}
+then
+  chmod 0644 "$tmp"
+  mv -f "$tmp" "$dir/${op.name}.out"
+else
+  status=$?
+  rm -f "$tmp"
+  exit "$status"
+fi
+`;
+}

package/dist/standalone/root-window.d.ts

@@ -0,0 +1,36 @@
+import { type RootOp } from "./root-ops.js";
+/** What the window embeds per root operation: the task it may create, and how to recognize it. */
+export interface RootTask {
+    op: string;
+    name: string;
+    header: string;
+    script: string;
+}
+export declare function rootTasks(manifest: {
+    package: string;
+    spkVersion: string;
+    rootOps?: RootOp[];
+}): RootTask[];
+/**
+ * `createRootAccess(options)` → `{ state, authorize, run, remove }`, plain
+ * ES5 for DSM's desktop. Every DSM call goes through `options.send` (the
+ * AppWindow's sendWebAPI) as the signed-in administrator:
+ *
+ * - authorize: DSM's own password confirmation, then one disabled root task
+ *   with exactly the embedded script. The one-use token goes into that single
+ *   create call and is never kept.
+ * - run: re-reads the task and runs it only if it is still exactly ours, then
+ *   waits for its history entry and asks the backend for the output. Repair
+ *   additionally requires fresh PasswordConfirm and another exact task check.
+ * - an older version of our task is "outdated" and never runs; authorizing
+ *   again replaces it. A same-named task that is not ours is a "conflict" and
+ *   is never run, replaced or deleted.
+ */
+export declare const ROOT_RUNTIME = "function createRootAccess(options) {\n  var API = \"SYNO.Core.TaskScheduler\";\n  var POLL_MS = 500, POLLS = 60;\n  var byOp = {};\n  options.tasks.forEach(function (task) { byOp[task.op] = task; });\n\n  function fail(code) {\n    var error = new Error(code);\n    error.code = code;\n    return error;\n  }\n  function begin(op) {\n    if (!Object.prototype.hasOwnProperty.call(byOp, op)) return Promise.reject(fail(\"root_unknown_op\"));\n    if (options.user().admin !== true) return Promise.reject(fail(\"admin_required\"));\n    return Promise.resolve(byOp[op]);\n  }\n  function isRootTask(summary) {\n    return summary.owner === \"root\" && summary.real_owner === \"root\" && summary.enable === false && summary.type === \"script\";\n  }\n  function find(task) {\n    return options.send(API, \"list\", 3, { start: 0, limit: 500 }).then(function (data) {\n      if (!data || !Array.isArray(data.tasks)) throw fail(\"root_bad_response\");\n      var named = data.tasks.filter(function (summary) { return summary && summary.name === task.name; });\n      if (named.length === 0) return { state: \"missing\" };\n      if (named.length > 1 || !isRootTask(named[0])) return { state: \"conflict\" };\n      var ref = { id: named[0].id, real_owner: named[0].real_owner };\n      return options.send(API, \"get\", 4, ref).then(function (detail) {\n        var script = detail && detail.extra && detail.extra.script;\n        if (!detail || String(detail.id) !== String(ref.id) || detail.name !== task.name\n            || detail.owner !== \"root\" || detail.enable !== false || detail.type !== \"script\" || typeof script !== \"string\") {\n          return { state: \"conflict\" };\n        }\n        if (script === task.script) return { state: \"ready\", ref: ref };\n        if (script.indexOf(task.header) === 0) return { state: \"outdated\", ref: ref };\n        return { state: \"conflict\" };\n      });\n    });\n  }\n  function definition(task, user) {\n    var hours = [];\n    for (var h = 1; h <= 23; h++) hours.push(h);\n    return {\n      name: task.name,\n      real_owner: user,\n      owner: \"root\",\n      enable: false,\n      type: \"script\",\n      schedule: {\n        date_type: 0, week_day: \"0,1,2,3,4,5,6\", repeat_date: 1001, monthly_week: [], hour: 0, minute: 0,\n        repeat_hour: 0, repeat_min: 0, last_work_hour: 0,\n        repeat_min_store_config: [1, 5, 10, 15, 20, 30], repeat_hour_store_config: hours\n      },\n      extra: { notify_enable: false, script: task.script, notify_mail: \"\", notify_if_error: false }\n    };\n  }\n  function newest(history) {\n    if (!Array.isArray(history)) throw fail(\"root_bad_response\");\n    return history.reduce(function (latest, entry) {\n      return entry && (!latest || Number(entry.timestamp) > Number(latest.timestamp)) ? entry : latest;\n    }, null);\n  }\n  function history(ref) {\n    return options.send(API, \"get_history_status_list\", 1, { id: ref.id }).then(newest);\n  }\n  function waitForRun(ref, before, polls) {\n    return history(ref).then(function (latest) {\n      var finished = latest && (!before || latest.timestamp !== before.timestamp)\n        && latest.exit_type !== \"running\" && latest.stop_time;\n      if (finished) {\n        if (latest.exit_code !== 0) throw fail(\"root_task_failed\");\n        return;\n      }\n      if (polls <= 1) throw fail(\"root_timeout\");\n      return options.wait(POLL_MS).then(function () { return waitForRun(ref, before, polls - 1); });\n    });\n  }\n\n  return {\n    state: function (op) {\n      return begin(op).then(find).then(function (found) { return found.state; });\n    },\n    authorize: function (op) {\n      return begin(op).then(function (task) {\n        return find(task).then(function (found) {\n          if (found.state === \"ready\") return \"ready\";\n          if (found.state === \"conflict\") throw fail(\"root_conflict\");\n          return options.confirmPassword().then(function (token) {\n            if (!token) return \"cancelled\";\n            var params = definition(task, options.user().name);\n            params.SynoConfirmPWToken = token;\n            var replaced = found.state === \"outdated\"\n              ? options.send(API, \"delete\", 2, { tasks: [found.ref] })\n              : Promise.resolve();\n            return replaced.then(function () {\n              return options.send(API + \".Root\", \"create\", 4, params);\n            }).then(function () {\n              return find(task);\n            }).then(function (after) {\n              if (after.state !== \"ready\") throw fail(\"root_verify_failed\");\n              return \"ready\";\n            });\n          });\n        });\n      });\n    },\n    run: function (op) {\n      return begin(op).then(function (task) {\n        return find(task).then(function (found) {\n          if (found.state !== \"ready\") throw fail(\"root_not_ready\");\n          // Repair requires fresh interactive consent even for a retained task.\n          // Confirmation tokens are never cached or reused as scheduler tokens.\n          var consent = op === \"helper_repair\" ? options.confirmPassword() : Promise.resolve(true);\n          return consent.then(function (token) {\n            if (!token) throw fail(\"root_cancelled\");\n            // The user may leave the dialog open while the scheduler changes.\n            return op === \"helper_repair\" ? begin(op).then(find) : found;\n          }).then(function (verified) {\n            if (verified.state !== \"ready\") throw fail(\"root_not_ready\");\n            return history(verified.ref).then(function (before) {\n              return options.send(API, \"run\", 2, { tasks: [verified.ref] }).then(function () {\n                return waitForRun(verified.ref, before, POLLS);\n              });\n            });\n          });\n        }).then(function () {\n          return options.call(\"root.output\", { op: op });\n        });\n      });\n    },\n    remove: function (op) {\n      return begin(op).then(function (task) {\n        return find(task).then(function (found) {\n          if (found.state === \"missing\") return \"missing\";\n          if (found.state === \"conflict\") throw fail(\"root_conflict\");\n          return options.send(API, \"delete\", 2, { tasks: [found.ref] }).then(function () {\n            return find(task);\n          }).then(function (after) {\n            if (after.state !== \"missing\") throw fail(\"root_verify_failed\");\n            return \"missing\";\n          });\n        });\n      });\n    },\n    output: function (op) {\n      return begin(op).then(function () {\n        return options.call(\"root.output\", { op: op });\n      });\n    }\n  };\n}";
+/**
+ * The authorization panel the window shows above the app for each root
+ * operation, identical in every package. `rootPanelView(model)` decides what
+ * it shows; `mountRootPanel(host, access, i18n, tasks, admin)` draws it with
+ * DOM text nodes only (no HTML from data).
+ */
+export declare const ROOT_PANEL = "function rootPanelShowsResult(state) {\n  return state === \"ready\" || state === \"outdated\";\n}\n\nfunction rootPanelView(model) {\n  if (!model.admin) return { status: null, buttons: [], message: { key: \"admin_only\" } };\n  function buttons(actions) {\n    return actions.map(function (action) { return { action: action, disabled: model.busy === true }; });\n  }\n  if (model.error) {\n    return {\n      status: \"state.\" + model.state, buttons: buttons([\"retry\"]),\n      message: { key: \"error.\" + model.error, params: { name: model.name, code: model.error } }\n    };\n  }\n  var message = model.notice ? { key: model.notice } : null;\n  switch (model.state) {\n    case \"missing\":\n      return { status: \"state.missing\", buttons: buttons([\"authorize\"]), message: message };\n    case \"outdated\":\n      return { status: \"state.outdated\", buttons: buttons([\"authorize\", \"remove\"]), message: message };\n    case \"ready\":\n      return { status: \"state.ready\", buttons: buttons([\"run\", \"remove\"]), message: message };\n    case \"conflict\":\n      return { status: \"state.conflict\", buttons: buttons([\"retry\"]), message: { key: \"error.root_conflict\", params: { name: model.name } } };\n    default:\n      return { status: \"state.checking\", buttons: [], message: null };\n  }\n}\n\nfunction mountRootPanel(host, access, i18n, tasks, admin) {\n  var t = i18n.t;\n  function el(tag, className, text) {\n    var node = document.createElement(tag);\n    if (className) node.className = className;\n    if (text !== undefined) node.textContent = text;\n    return node;\n  }\n  function say(message) {\n    if (!message) return \"\";\n    var text = t(message.key, message.params);\n    return text === message.key && message.key.indexOf(\"error.\") === 0 ? t(\"error.default\", message.params) : text;\n  }\n  tasks.forEach(function (task) {\n    var model = { admin: admin, name: task.name, state: \"checking\", busy: false, error: null, notice: null };\n    var result = null;\n    var section = el(\"section\", \"dsmapp-rootpanel\");\n    host.appendChild(section);\n\n    function render() {\n      var view = rootPanelView(model);\n      while (section.firstChild) section.removeChild(section.firstChild);\n      section.appendChild(el(\"h2\", null, t(\"title\")));\n      section.appendChild(el(\"p\", null, t(\"intro\", { op: task.op })));\n      if (view.status) {\n        var facts = el(\"dl\");\n        facts.appendChild(el(\"dt\", null, t(\"status\")));\n        facts.appendChild(el(\"dd\", \"dsmapp-rootpanel-state\", t(view.status, { name: task.name })));\n        facts.appendChild(el(\"dt\", null, t(\"last_run\")));\n        facts.appendChild(el(\"dd\", null, result && result.modified\n          ? new Date(result.modified * 1000).toLocaleString(i18n.locale) : t(\"never\")));\n        section.appendChild(facts);\n      }\n      if (view.message) section.appendChild(el(\"p\", \"dsmapp-rootpanel-message\", say(view.message)));\n      if (result && typeof result.output === \"string\") {\n        section.appendChild(el(\"div\", \"dsmapp-rootpanel-label\", t(\"output\")));\n        section.appendChild(el(\"pre\", \"dsmapp-rootpanel-output\", result.output));\n      }\n      var actions = el(\"div\", \"dsmapp-rootpanel-actions\");\n      view.buttons.forEach(function (button) {\n        var node = el(\"button\", button.action === \"remove\" ? null : \"dsmapp-rootpanel-primary\", t(button.action));\n        node.type = \"button\";\n        node.disabled = button.disabled;\n        node.onclick = function () { act(button.action); };\n        actions.appendChild(node);\n      });\n      section.appendChild(actions);\n      if (admin && rootPanelShowsResult(model.state)) section.appendChild(el(\"p\", \"dsmapp-rootpanel-hint\", t(\"uninstall_hint\")));\n    }\n    function settle(promise, notice) {\n      model.busy = true;\n      model.error = null;\n      model.notice = null;\n      render();\n      return promise.then(function (value) {\n        model.notice = typeof notice === \"function\" ? notice(value) : notice;\n      }, function (error) {\n        if (error && error.code === \"root_cancelled\") model.notice = \"cancelled\";\n        else model.error = (error && error.code) || \"unknown\";\n      }).then(function () {\n        model.busy = false;\n        render();\n      });\n    }\n    function refresh(notice) {\n      return settle(access.state(task.op).then(function (state) {\n        model.state = state;\n        if (!rootPanelShowsResult(state)) return;\n        return access.output(task.op).then(function (out) { result = out; });\n      }), notice);\n    }\n    function refreshAfterChange() {\n      return model.error ? null : refresh(model.notice);\n    }\n    function act(action) {\n      if (action === \"retry\") return refresh(null);\n      if (action === \"authorize\") {\n        return settle(access.authorize(task.op), function (outcome) {\n          return outcome === \"cancelled\" ? \"cancelled\" : null;\n        }).then(refreshAfterChange);\n      }\n      if (action === \"run\") {\n        return settle(access.run(task.op).then(function (out) { result = out; }), \"completed\");\n      }\n      if (action === \"remove\") {\n        return settle(access.remove(task.op).then(function () { result = null; }), null).then(refreshAfterChange);\n      }\n    }\n    render();\n    if (admin) refresh(null);\n  });\n}";