@synopackageland/cli 0.5.0 → 0.6.0

package/dist/standalone/native-layout.js

@@ -1,318 +0,0 @@
-/** Existing native products: the CLI owns archives/INFO, the project owns its layout. */
-import { createHash } from 'node:crypto';
-import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
-import { parse } from 'yaml';
-import { createReproducibleTar } from '../build-spk/reproducible-archive.js';
-import { runCommand } from './build.js';
-export const LAYOUT_ARCHES = { x86_64: [2, 62], aarch64: [2, 183], armv8: [2, 183], armv7: [1, 40] };
-function fail(message) { throw new Error(`NATIVE_LAYOUT_INVALID: ${message}`); }
-const digest = (bytes) => createHash('sha256').update(bytes).digest('hex');
-function object(value, fields) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        fail('expected object');
-    const obj = value;
-    if (Object.keys(obj).some(k => !fields.includes(k)))
-        fail('unknown field');
-    return obj;
-}
-function text(value) {
-    if (typeof value !== 'string' || !value || /[\r\n"\\\0]/.test(value))
-        fail('invalid text');
-    return value;
-}
-function pathText(value) {
-    const path = text(value);
-    if (isAbsolute(path) || path.split('/').some(p => p === '..' || p === '') || /[{}]/.test(path.replaceAll('{arch}', '')))
-        fail('path must stay inside project');
-    return path;
-}
-function inside(root, path) {
-    const full = resolve(root, path);
-    const rel = relative(realpathSync(root), realpathSync(full));
-    if (rel === '..' || rel.startsWith('../') || isAbsolute(rel))
-        fail('path escapes project');
-    return full;
-}
-function hook(value) {
-    const h = object(value, ['command', 'cwd', 'env']);
-    if (!Array.isArray(h.command) || !h.command.length || !h.command.every((x) => typeof x === 'string' && x.length > 0 && !x.includes('\0')))
-        fail('hook requires argv');
-    const env = object(h.env ?? {}, Object.keys(h.env ?? {}));
-    for (const [key, value] of Object.entries(env))
-        if (!/^[A-Z_][A-Z0-9_]*$/.test(key) || typeof value !== 'string' || value.includes('\0') || key.startsWith('SYNOPKGLAND_'))
-            fail('invalid hook environment');
-    return { command: h.command, cwd: pathText(h.cwd ?? '.'), env };
-}
-export function isNativeLayout(root) {
-    try {
-        return parse(readFileSync(join(root, 'dsm-package.yaml'), 'utf8'))?.layout !== undefined;
-    }
-    catch {
-        return false;
-    }
-}
-export function loadNativeLayout(root) {
-    try {
-        const m = object(parse(readFileSync(join(root, 'dsm-package.yaml'), 'utf8')), ['schema', 'package', 'version', 'build', 'displayname', 'description', 'maintainer', 'os_min_ver', 'privilege', 'arches', 'layout', 'native']);
-        if (m.schema !== 1 || m.privilege !== 'none')
-            fail('schema 1 and privilege: none required');
-        if (!/^[A-Za-z][A-Za-z0-9]{1,63}$/.test(text(m.package)) || !/^\d+(\.\d+){0,3}$/.test(text(m.version)) || !/^7\.\d+(\.\d+)?-\d+$/.test(text(m.os_min_ver)))
-            fail('invalid package/version/DSM');
-        if (!Number.isSafeInteger(m.build) || m.build < 1 || m.build > 2147483647)
-            fail('build must be 1..2147483647');
-        for (const k of ['displayname', 'description', 'maintainer'])
-            text(m[k]);
-        if (!Array.isArray(m.arches) || !m.arches.length || new Set(m.arches).size !== m.arches.length || m.arches.some((a) => !Object.hasOwn(LAYOUT_ARCHES, a)))
-            fail('invalid architecture list');
-        const layout = object(m.layout, ['payload', 'metadata', 'binaries']);
-        layout.payload = pathText(layout.payload);
-        layout.metadata = pathText(layout.metadata);
-        if (!Array.isArray(layout.binaries) || !layout.binaries.length)
-            fail('binary assertions required');
-        for (const b of layout.binaries) {
-            object(b, ['path', 'linkage', 'arches']);
-            pathText(b.path);
-            if (!['static', 'dynamic'].includes(b.linkage))
-                fail('declare binary linkage');
-            if (b.arches !== undefined && (!Array.isArray(b.arches) || !b.arches.length || b.arches.some((a) => !m.arches.includes(a))))
-                fail('invalid binary arches');
-        }
-        const native = object(m.native, ['prepare', 'hook', 'toolkits']);
-        const toolkits = object(native.toolkits ?? {}, m.arches);
-        for (const entries of Object.values(toolkits)) {
-            if (!Array.isArray(entries) || !entries.length)
-                fail('toolkits require archives');
-            for (const t of entries) {
-                object(t, ['url', 'sha256']);
-                const u = new URL(t.url);
-                if (u.protocol !== 'https:' || u.username || u.password || !/^[a-f0-9]{64}$/.test(t.sha256))
-                    fail('toolkits require HTTPS and SHA-256');
-            }
-        }
-        return { ok: true, manifest: { ...m, root: resolve(root), native: { hook: hook(native.hook), ...(native.prepare ? { prepare: hook(native.prepare) } : {}), toolkits } } };
-    }
-    catch (error) {
-        return { ok: false, errors: [{ code: 'NATIVE_LAYOUT_INVALID', message: String(error) }] };
-    }
-}
-export function verifyToolkitArchive(path, expected) {
-    if (!lstatSync(path).isFile() || digest(readFileSync(path)) !== expected)
-        fail('toolkit checksum mismatch');
-}
-async function toolkitFor(m, arch, run) {
-    const inputs = m.native.toolkits[arch] ?? [];
-    if (!inputs.length)
-        return '';
-    const cache = resolve(process.env.SYNOPKGLAND_CACHE_DIR ?? join(m.root, '.synopkgland-cache'));
-    mkdirSync(cache, { recursive: true, mode: 0o700 });
-    if (lstatSync(cache).isSymbolicLink() || (lstatSync(cache).mode & 0o022))
-        fail('toolkit cache must be owned and private');
-    const archives = [];
-    for (const input of inputs) {
-        const archive = join(cache, `${input.sha256}.txz`);
-        if (!existsSync(archive)) {
-            const download = mkdtempSync(join(cache, '.download-'));
-            try {
-                const out = join(download, 'archive');
-                const r = run('curl', ['--fail', '--location', '--proto', '=https', '--proto-redir', '=https', '--retry', '2', '--retry-all-errors', '--connect-timeout', '20', '--max-time', '600', '--output', out, input.url], { cwd: m.root, env: { ...process.env } });
-                if (r.status !== 0)
-                    fail('toolkit download failed');
-                verifyToolkitArchive(out, input.sha256);
-                renameSync(out, archive);
-            }
-            finally {
-                rmSync(download, { recursive: true, force: true });
-            }
-        }
-        verifyToolkitArchive(archive, input.sha256);
-        archives.push(archive);
-    }
-    // Re-extract verified bytes: a package-writable marker never authenticates an extracted tree.
-    const stage = mkdtempSync(join(cache, `toolkit-${arch}-`));
-    try {
-        for (const archive of archives) {
-            const r = run('tar', ['-xJf', archive, '-C', stage, '--keep-directory-symlink'], { cwd: m.root, env: { ...process.env } });
-            if (r.status !== 0)
-                fail('toolkit extraction failed');
-        }
-        return stage;
-    }
-    catch (e) {
-        rmSync(stage, { recursive: true, force: true });
-        throw e;
-    }
-}
-function runHook(m, h, env, run) {
-    const [cmd, ...args] = h.command;
-    const r = run(cmd, args, { cwd: inside(m.root, h.cwd), env: { ...process.env, ...h.env, ...env } });
-    if (r.status !== 0 || r.missing)
-        fail(`native hook failed: ${r.stderr}`);
-}
-export function layoutFiles(root) {
-    if (!lstatSync(root).isDirectory() || lstatSync(root).isSymbolicLink())
-        fail('layout root must be a regular directory');
-    const files = [];
-    let total = 0;
-    const walk = (prefix) => {
-        for (const name of readdirSync(join(root, prefix)).sort()) {
-            const path = prefix ? `${prefix}/${name}` : name;
-            const s = lstatSync(join(root, path));
-            if (s.isSymbolicLink() || (!s.isFile() && !s.isDirectory()))
-                fail('layout contains symlink or special file');
-            if (s.mode & 0o6000)
-                fail('privileged file modes are forbidden');
-            if (s.isDirectory())
-                walk(path);
-            else {
-                total += s.size;
-                if (s.size > 256 * 1024 * 1024 || total > 1024 * 1024 * 1024)
-                    fail('layout exceeds size bound');
-                files.push({ path, mode: s.mode & 0o111 ? 0o755 : 0o644, sha256: digest(readFileSync(join(root, path))) });
-            }
-        }
-    };
-    walk('');
-    return files;
-}
-export function checkLayoutBinary(root, b, arch) {
-    const path = inside(root, b.path);
-    const bytes = readFileSync(path);
-    const [cls, machine] = LAYOUT_ARCHES[arch];
-    if (bytes.length < 64 || bytes.toString('latin1', 0, 4) !== '\x7fELF' || bytes[4] !== cls || bytes[5] !== 1 || bytes.readUInt16LE(18) !== machine || ![2, 3].includes(bytes.readUInt16LE(16)))
-        fail(`ELF architecture mismatch: ${b.path}`);
-    const offset = cls === 1 ? bytes.readUInt32LE(28) : Number(bytes.readBigUInt64LE(32));
-    const size = bytes.readUInt16LE(cls === 1 ? 42 : 54);
-    const count = bytes.readUInt16LE(cls === 1 ? 44 : 56);
-    if (!count || size < (cls === 1 ? 32 : 56) || !Number.isSafeInteger(offset) || offset + size * count > bytes.length)
-        fail('invalid ELF program headers');
-    let dynamic = false;
-    for (let i = 0; i < count; i++)
-        if (bytes.readUInt32LE(offset + size * i) === 3)
-            dynamic = true;
-    if (dynamic !== (b.linkage === 'dynamic'))
-        fail(`ELF linkage mismatch: ${b.path}`);
-    if (!(lstatSync(path).mode & 0o111))
-        fail(`binary must be executable: ${b.path}`);
-}
-function copyTree(from, to) {
-    const entries = layoutFiles(from);
-    for (const entry of entries) {
-        const out = join(to, entry.path);
-        mkdirSync(dirname(out), { recursive: true });
-        copyFileSync(join(from, entry.path), out);
-        chmodSync(out, entry.mode);
-    }
-    return entries;
-}
-export function checkLayoutMetadata(root, inspection = false, packageId) {
-    const p = JSON.parse(readFileSync(join(root, 'conf/privilege'), 'utf8'));
-    if (p.defaults?.['run-as'] !== 'package' || Object.keys(p).some(k => !['defaults', 'username', 'groupname'].includes(k)) || ['username', 'groupname'].some(k => p[k] !== undefined && p[k] !== packageId) || Object.keys(p.defaults).some(k => k !== 'run-as'))
-        fail('native layout requires package-only lifecycle privilege');
-    if (!existsSync(join(root, 'scripts/start-stop-status')))
-        fail('start-stop-status missing');
-    if (existsSync(join(root, 'conf/resource'))) {
-        const resource = object(JSON.parse(readFileSync(join(root, 'conf/resource'), 'utf8')), ['systemd-unit']);
-        if (resource['systemd-unit'] !== undefined && Object.keys(object(resource['systemd-unit'], [])).length)
-            fail('unsupported resource worker');
-    }
-    if (existsSync(join(root, 'conf/systemd'))) {
-        for (const entry of layoutFiles(join(root, 'conf/systemd'))) {
-            const unit = readFileSync(join(root, 'conf/systemd', entry.path), 'utf8');
-            const users = [...unit.matchAll(/^\s*User\s*=\s*(.*?)\s*$/gm)].map(m => m[1]);
-            const groups = [...unit.matchAll(/^\s*Group\s*=\s*(.*?)\s*$/gm)].map(m => m[1]);
-            if (!packageId || users.length !== 1 || users[0] !== packageId || groups.some(group => group !== packageId) || /^\s*(?:AmbientCapabilities|SupplementaryGroups|PermissionsStartOnly|RootDirectory|RootImage)\s*=/m.test(unit) || /^\s*Exec\w*\s*=\s*[+!]/m.test(unit))
-                fail('systemd unit must run only as the package account');
-        }
-    }
-    for (const name of readdirSync(root))
-        if (!['conf', 'scripts', 'WIZARD_UIFILES', 'PACKAGE_ICON.PNG', 'PACKAGE_ICON_256.PNG', ...(inspection ? ['INFO', 'package.tgz', 'native-layout.json', 'layout-inspection'] : [])].includes(name))
-            fail(`unsupported SPK metadata: ${name}`);
-    for (const f of layoutFiles(root)) {
-        if (f.path.startsWith('scripts/') && /\bsudo\b|\bchown\s+root\b|chmod\s+[ugo]*\+s\b/.test(readFileSync(join(root, f.path), 'utf8')))
-            fail('root lifecycle operation forbidden');
-    }
-}
-export async function buildNativeLayout(options) {
-    const loaded = loadNativeLayout(options.root);
-    if (!loaded.ok)
-        fail(loaded.errors.map(e => e.message).join('\n'));
-    const m = loaded.manifest;
-    if (options.build !== undefined) {
-        if (!Number.isSafeInteger(options.build) || options.build < 1 || options.build > 2147483647)
-            fail('invalid build override');
-        m.build = options.build;
-    }
-    const arches = options.arches ?? m.arches;
-    if (!arches.length || new Set(arches).size !== arches.length || arches.some(a => !m.arches.includes(a)))
-        fail('architecture not declared');
-    const run = options.run ?? runCommand;
-    const version = `${m.version}-${String(m.build).padStart(4, '0')}`;
-    const env = { SYNOPKGLAND_PACKAGE: m.package, SYNOPKGLAND_VERSION: m.version, SYNOPKGLAND_BUILD: String(m.build), SYNOPKGLAND_SPK_VERSION: version, SYNOPKGLAND_PROJECT_DIR: m.root };
-    if (m.native.prepare)
-        runHook(m, m.native.prepare, env, run);
-    const outputs = [];
-    for (const requested of arches) {
-        const arch = requested;
-        const toolkit = await toolkitFor(m, arch, run);
-        const stage = mkdtempSync(join(tmpdir(), 'synopkgland-layout-'));
-        try {
-            runHook(m, m.native.hook, { ...env, SYNOPKGLAND_ARCH: arch, SYNOPKGLAND_TOOLKIT_DIR: toolkit }, run);
-            const payload = inside(m.root, m.layout.payload.replaceAll('{arch}', arch));
-            const metadata = inside(m.root, m.layout.metadata);
-            checkLayoutMetadata(metadata, false, m.package);
-            layoutFiles(payload);
-            const binaries = m.layout.binaries.filter(b => !b.arches || b.arches.includes(arch));
-            if (!binaries.length)
-                fail("binary assertions required for every architecture");
-            for (const b of binaries)
-                checkLayoutBinary(payload, b, arch);
-            copyTree(metadata, stage);
-            const target = join(stage, 'payload');
-            mkdirSync(target);
-            const files = copyTree(payload, target);
-            await createReproducibleTar(target, join(stage, 'package.tgz'), { gzip: true });
-            rmSync(target, { recursive: true });
-            const fields = { package: m.package, version, arch, os_min_ver: m.os_min_ver, displayname: m.displayname, description: m.description, maintainer: m.maintainer, dsmuidir: 'ui', dsmappname: `SYNO.SDS.${m.package}.Instance`, startable: 'yes', thirdparty: 'yes', checksum: createHash('md5').update(readFileSync(join(stage, 'package.tgz'))).digest('hex') };
-            writeFileSync(join(stage, 'INFO'), Object.entries(fields).map(([k, v]) => `${k}="${v}"\n`).join(''));
-            writeFileSync(join(stage, 'native-layout.json'), JSON.stringify({ format: 1, arch, binaries: binaries.map(({ path, linkage }) => ({ path, linkage })), files }));
-            const output = join(options.outDir ?? join(m.root, 'dist'), `${m.package}-${version}-${arch}.spk`);
-            mkdirSync(dirname(output), { recursive: true });
-            await createReproducibleTar(stage, output);
-            outputs.push(output);
-        }
-        finally {
-            rmSync(stage, { recursive: true, force: true });
-            if (toolkit)
-                rmSync(toolkit, { recursive: true, force: true });
-        }
-    }
-    return { outputs };
-}
-export function inspectNativeLayout(dir, payload, info) {
-    try {
-        const inv = object(JSON.parse(readFileSync(join(dir, 'native-layout.json'), 'utf8')), ['format', 'arch', 'binaries', 'files']);
-        if (inv.format !== 1 || inv.arch !== info.arch || !Object.hasOwn(LAYOUT_ARCHES, inv.arch))
-            fail('invalid native layout inventory');
-        checkLayoutMetadata(dir, true, info.package);
-        const actual = layoutFiles(payload);
-        if (JSON.stringify(actual) !== JSON.stringify(inv.files))
-            fail('payload checksum or mode mismatch');
-        if (!Array.isArray(inv.binaries) || !inv.binaries.length)
-            fail('missing binary assertions');
-        for (const b of inv.binaries) {
-            object(b, ['path', 'linkage']);
-            pathText(b.path);
-            if (!['static', 'dynamic'].includes(b.linkage))
-                fail('invalid linkage');
-            checkLayoutBinary(payload, b, inv.arch);
-        }
-        if (createHash('md5').update(readFileSync(join(dir, 'package.tgz'))).digest('hex') !== info.checksum)
-            fail('package checksum mismatch');
-        return [];
-    }
-    catch (e) {
-        return [String(e)];
-    }
-}

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

@@ -1,7 +0,0 @@
-import type { Catalog, Locale } from "./i18n.js";
-/**
- * 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 declare const ROOT_MESSAGES: Record<Locale, Catalog>;

package/dist/standalone/root-messages.js

@@ -1,259 +0,0 @@
-/**
- * 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/worker-contract-json.d.ts

@@ -1,8 +0,0 @@
-import type { WorkerSafeReason } from "./worker-contract.js";
-export declare class WorkerContractError extends Error {
-    readonly code: WorkerSafeReason;
-    constructor(code: WorkerSafeReason);
-}
-export declare function fail(code?: WorkerSafeReason): never;
-export declare function validUnicode(s: string): boolean;
-export declare function strictJSON(raw: string | Uint8Array, cap: number): unknown;