@synopackageland/cli 0.3.10 → 0.4.1

package/dist/standalone/root-window.js

@@ -0,0 +1,302 @@
+import { renderRootTaskScript, rootTaskHeader, rootTaskName } from "./root-ops.js";
+export function rootTasks(manifest) {
+    return (manifest.rootOps ?? []).map((op) => ({
+        op: op.name,
+        name: rootTaskName(manifest.package, op.name),
+        header: rootTaskHeader(manifest.package, op.name),
+        script: renderRootTaskScript(manifest, op),
+    }));
+}
+/**
+ * `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 const ROOT_RUNTIME = `function createRootAccess(options) {
+  var API = "SYNO.Core.TaskScheduler";
+  var POLL_MS = 500, POLLS = 60;
+  var byOp = {};
+  options.tasks.forEach(function (task) { byOp[task.op] = task; });
+
+  function fail(code) {
+    var error = new Error(code);
+    error.code = code;
+    return error;
+  }
+  function begin(op) {
+    if (!Object.prototype.hasOwnProperty.call(byOp, op)) return Promise.reject(fail("root_unknown_op"));
+    if (options.user().admin !== true) return Promise.reject(fail("admin_required"));
+    return Promise.resolve(byOp[op]);
+  }
+  function isRootTask(summary) {
+    return summary.owner === "root" && summary.real_owner === "root" && summary.enable === false && summary.type === "script";
+  }
+  function find(task) {
+    return options.send(API, "list", 3, { start: 0, limit: 500 }).then(function (data) {
+      if (!data || !Array.isArray(data.tasks)) throw fail("root_bad_response");
+      var named = data.tasks.filter(function (summary) { return summary && summary.name === task.name; });
+      if (named.length === 0) return { state: "missing" };
+      if (named.length > 1 || !isRootTask(named[0])) return { state: "conflict" };
+      var ref = { id: named[0].id, real_owner: named[0].real_owner };
+      return options.send(API, "get", 4, ref).then(function (detail) {
+        var script = detail && detail.extra && detail.extra.script;
+        if (!detail || String(detail.id) !== String(ref.id) || detail.name !== task.name
+            || detail.owner !== "root" || detail.enable !== false || detail.type !== "script" || typeof script !== "string") {
+          return { state: "conflict" };
+        }
+        if (script === task.script) return { state: "ready", ref: ref };
+        if (script.indexOf(task.header) === 0) return { state: "outdated", ref: ref };
+        return { state: "conflict" };
+      });
+    });
+  }
+  function definition(task, user) {
+    var hours = [];
+    for (var h = 1; h <= 23; h++) hours.push(h);
+    return {
+      name: task.name,
+      real_owner: user,
+      owner: "root",
+      enable: false,
+      type: "script",
+      schedule: {
+        date_type: 0, week_day: "0,1,2,3,4,5,6", repeat_date: 1001, monthly_week: [], hour: 0, minute: 0,
+        repeat_hour: 0, repeat_min: 0, last_work_hour: 0,
+        repeat_min_store_config: [1, 5, 10, 15, 20, 30], repeat_hour_store_config: hours
+      },
+      extra: { notify_enable: false, script: task.script, notify_mail: "", notify_if_error: false }
+    };
+  }
+  function newest(history) {
+    if (!Array.isArray(history)) throw fail("root_bad_response");
+    return history.reduce(function (latest, entry) {
+      return entry && (!latest || Number(entry.timestamp) > Number(latest.timestamp)) ? entry : latest;
+    }, null);
+  }
+  function history(ref) {
+    return options.send(API, "get_history_status_list", 1, { id: ref.id }).then(newest);
+  }
+  function waitForRun(ref, before, polls) {
+    return history(ref).then(function (latest) {
+      var finished = latest && (!before || latest.timestamp !== before.timestamp)
+        && latest.exit_type !== "running" && latest.stop_time;
+      if (finished) {
+        if (latest.exit_code !== 0) throw fail("root_task_failed");
+        return;
+      }
+      if (polls <= 1) throw fail("root_timeout");
+      return options.wait(POLL_MS).then(function () { return waitForRun(ref, before, polls - 1); });
+    });
+  }
+
+  return {
+    state: function (op) {
+      return begin(op).then(find).then(function (found) { return found.state; });
+    },
+    authorize: function (op) {
+      return begin(op).then(function (task) {
+        return find(task).then(function (found) {
+          if (found.state === "ready") return "ready";
+          if (found.state === "conflict") throw fail("root_conflict");
+          return options.confirmPassword().then(function (token) {
+            if (!token) return "cancelled";
+            var params = definition(task, options.user().name);
+            params.SynoConfirmPWToken = token;
+            var replaced = found.state === "outdated"
+              ? options.send(API, "delete", 2, { tasks: [found.ref] })
+              : Promise.resolve();
+            return replaced.then(function () {
+              return options.send(API + ".Root", "create", 4, params);
+            }).then(function () {
+              return find(task);
+            }).then(function (after) {
+              if (after.state !== "ready") throw fail("root_verify_failed");
+              return "ready";
+            });
+          });
+        });
+      });
+    },
+    run: function (op) {
+      return begin(op).then(function (task) {
+        return find(task).then(function (found) {
+          if (found.state !== "ready") throw fail("root_not_ready");
+          // Repair requires fresh interactive consent even for a retained task.
+          // Confirmation tokens are never cached or reused as scheduler tokens.
+          var consent = op === "helper_repair" ? options.confirmPassword() : Promise.resolve(true);
+          return consent.then(function (token) {
+            if (!token) throw fail("root_cancelled");
+            // The user may leave the dialog open while the scheduler changes.
+            return op === "helper_repair" ? begin(op).then(find) : found;
+          }).then(function (verified) {
+            if (verified.state !== "ready") throw fail("root_not_ready");
+            return history(verified.ref).then(function (before) {
+              return options.send(API, "run", 2, { tasks: [verified.ref] }).then(function () {
+                return waitForRun(verified.ref, before, POLLS);
+              });
+            });
+          });
+        }).then(function () {
+          return options.call("root.output", { op: op });
+        });
+      });
+    },
+    remove: function (op) {
+      return begin(op).then(function (task) {
+        return find(task).then(function (found) {
+          if (found.state === "missing") return "missing";
+          if (found.state === "conflict") throw fail("root_conflict");
+          return options.send(API, "delete", 2, { tasks: [found.ref] }).then(function () {
+            return find(task);
+          }).then(function (after) {
+            if (after.state !== "missing") throw fail("root_verify_failed");
+            return "missing";
+          });
+        });
+      });
+    },
+    output: function (op) {
+      return begin(op).then(function () {
+        return options.call("root.output", { op: op });
+      });
+    }
+  };
+}`;
+/**
+ * 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 const ROOT_PANEL = `function rootPanelShowsResult(state) {
+  return state === "ready" || state === "outdated";
+}
+
+function rootPanelView(model) {
+  if (!model.admin) return { status: null, buttons: [], message: { key: "admin_only" } };
+  function buttons(actions) {
+    return actions.map(function (action) { return { action: action, disabled: model.busy === true }; });
+  }
+  if (model.error) {
+    return {
+      status: "state." + model.state, buttons: buttons(["retry"]),
+      message: { key: "error." + model.error, params: { name: model.name, code: model.error } }
+    };
+  }
+  var message = model.notice ? { key: model.notice } : null;
+  switch (model.state) {
+    case "missing":
+      return { status: "state.missing", buttons: buttons(["authorize"]), message: message };
+    case "outdated":
+      return { status: "state.outdated", buttons: buttons(["authorize", "remove"]), message: message };
+    case "ready":
+      return { status: "state.ready", buttons: buttons(["run", "remove"]), message: message };
+    case "conflict":
+      return { status: "state.conflict", buttons: buttons(["retry"]), message: { key: "error.root_conflict", params: { name: model.name } } };
+    default:
+      return { status: "state.checking", buttons: [], message: null };
+  }
+}
+
+function mountRootPanel(host, access, i18n, tasks, admin) {
+  var t = i18n.t;
+  function el(tag, className, text) {
+    var node = document.createElement(tag);
+    if (className) node.className = className;
+    if (text !== undefined) node.textContent = text;
+    return node;
+  }
+  function say(message) {
+    if (!message) return "";
+    var text = t(message.key, message.params);
+    return text === message.key && message.key.indexOf("error.") === 0 ? t("error.default", message.params) : text;
+  }
+  tasks.forEach(function (task) {
+    var model = { admin: admin, name: task.name, state: "checking", busy: false, error: null, notice: null };
+    var result = null;
+    var section = el("section", "dsmapp-rootpanel");
+    host.appendChild(section);
+
+    function render() {
+      var view = rootPanelView(model);
+      while (section.firstChild) section.removeChild(section.firstChild);
+      section.appendChild(el("h2", null, t("title")));
+      section.appendChild(el("p", null, t("intro", { op: task.op })));
+      if (view.status) {
+        var facts = el("dl");
+        facts.appendChild(el("dt", null, t("status")));
+        facts.appendChild(el("dd", "dsmapp-rootpanel-state", t(view.status, { name: task.name })));
+        facts.appendChild(el("dt", null, t("last_run")));
+        facts.appendChild(el("dd", null, result && result.modified
+          ? new Date(result.modified * 1000).toLocaleString(i18n.locale) : t("never")));
+        section.appendChild(facts);
+      }
+      if (view.message) section.appendChild(el("p", "dsmapp-rootpanel-message", say(view.message)));
+      if (result && typeof result.output === "string") {
+        section.appendChild(el("div", "dsmapp-rootpanel-label", t("output")));
+        section.appendChild(el("pre", "dsmapp-rootpanel-output", result.output));
+      }
+      var actions = el("div", "dsmapp-rootpanel-actions");
+      view.buttons.forEach(function (button) {
+        var node = el("button", button.action === "remove" ? null : "dsmapp-rootpanel-primary", t(button.action));
+        node.type = "button";
+        node.disabled = button.disabled;
+        node.onclick = function () { act(button.action); };
+        actions.appendChild(node);
+      });
+      section.appendChild(actions);
+      if (admin && rootPanelShowsResult(model.state)) section.appendChild(el("p", "dsmapp-rootpanel-hint", t("uninstall_hint")));
+    }
+    function settle(promise, notice) {
+      model.busy = true;
+      model.error = null;
+      model.notice = null;
+      render();
+      return promise.then(function (value) {
+        model.notice = typeof notice === "function" ? notice(value) : notice;
+      }, function (error) {
+        if (error && error.code === "root_cancelled") model.notice = "cancelled";
+        else model.error = (error && error.code) || "unknown";
+      }).then(function () {
+        model.busy = false;
+        render();
+      });
+    }
+    function refresh(notice) {
+      return settle(access.state(task.op).then(function (state) {
+        model.state = state;
+        if (!rootPanelShowsResult(state)) return;
+        return access.output(task.op).then(function (out) { result = out; });
+      }), notice);
+    }
+    function refreshAfterChange() {
+      return model.error ? null : refresh(model.notice);
+    }
+    function act(action) {
+      if (action === "retry") return refresh(null);
+      if (action === "authorize") {
+        return settle(access.authorize(task.op), function (outcome) {
+          return outcome === "cancelled" ? "cancelled" : null;
+        }).then(refreshAfterChange);
+      }
+      if (action === "run") {
+        return settle(access.run(task.op).then(function (out) { result = out; }), "completed");
+      }
+      if (action === "remove") {
+        return settle(access.remove(task.op).then(function () { result = null; }), null).then(refreshAfterChange);
+      }
+    }
+    render();
+    if (admin) refresh(null);
+  });
+}`;

package/dist/standalone/spk.d.ts

@@ -0,0 +1,23 @@
+import { type NativeArchFamily } from "../build-spk/dsm-arch.js";
+import type { StandaloneManifest } from "./manifest.js";
+import type { HelperArtifact } from "./helper.js";
+export declare const LIFECYCLE_SCRIPTS: readonly ["preinst", "postinst", "preuninst", "postuninst", "preupgrade", "postupgrade", "start-stop-status"];
+export declare class StandaloneBuildError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface AssembleOptions {
+    manifest: StandaloneManifest;
+    arch: NativeArchFamily;
+    /** The compiled or prebuilt CGI executable, already checked. */
+    cgiPath: string;
+    outputPath: string;
+    helper?: HelperArtifact;
+    daemonControl?: string;
+}
+/**
+ * Packs an unsigned Standalone Package SPK. DSM runs installation/lifecycle
+ * as the package account, including an optional foreground daemon. Root
+ * integration remains separate and requires explicit administrator approval.
+ */
+export declare function assembleStandaloneSpk(options: AssembleOptions): Promise<void>;

package/dist/standalone/spk.js

@@ -0,0 +1,192 @@
+import { createHash } from "node:crypto";
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, relative, isAbsolute } from "node:path";
+import { infoArchValue } from "../build-spk/dsm-arch.js";
+import { writeDsmWindowIcons, writePackageCenterIcons } from "../build-spk/dsm-icons.js";
+import { renderNativePrivilege } from "../build-spk/native-lifecycle.js";
+import { createReproducibleTar } from "../build-spk/reproducible-archive.js";
+import { renderStandaloneScript } from "./lifecycle.js";
+import { DSM_LANGS, LOCALES } from "./i18n.js";
+import { CGI_PAYLOAD_PATH, renderUiConfig, renderWindowScript, windowScriptName } from "./dsm-window.js";
+import { copyStandaloneNotices } from "../build-spk/notices.js";
+import { hostScriptName, renderHostAdapterScript } from "./host-adapter.js";
+import { copyDaemonPayload } from "./daemon.js";
+const FILE_MODE = 0o644;
+const EXEC_MODE = 0o755;
+const MAX_UI_BYTES = 64 * 1024 * 1024;
+export const LIFECYCLE_SCRIPTS = [
+    "preinst",
+    "postinst",
+    "preuninst",
+    "postuninst",
+    "preupgrade",
+    "postupgrade",
+    "start-stop-status",
+];
+export class StandaloneBuildError extends Error {
+    code;
+    constructor(code, message) {
+        super(`[${code}] ${message}`);
+        this.code = code;
+    }
+}
+/**
+ * Packs an unsigned Standalone Package SPK. DSM runs installation/lifecycle
+ * as the package account, including an optional foreground daemon. Root
+ * integration remains separate and requires explicit administrator approval.
+ */
+export async function assembleStandaloneSpk(options) {
+    const { manifest } = options;
+    const staging = mkdtempSync(join(tmpdir(), "syno-standalone-spk-"));
+    try {
+        const uiRoot = join(staging, "package", "ui");
+        const appDir = join(uiRoot, "app");
+        copyUiTree(manifest.ui.dir, appDir);
+        const assetVersion = digestTree(appDir).slice(0, 12);
+        writeFile(join(uiRoot, "config"), renderUiConfig(manifest));
+        writeFile(join(uiRoot, windowScriptName(manifest)), renderWindowScript(manifest, assetVersion));
+        writeFile(join(uiRoot, hostScriptName(manifest.build)), renderHostAdapterScript(manifest.package));
+        writeDsmWindowIcons(uiRoot);
+        const cgiTarget = join(staging, "package", CGI_PAYLOAD_PATH);
+        mkdirSync(dirname(cgiTarget), { recursive: true });
+        copyFileSync(options.cgiPath, cgiTarget);
+        chmodSync(cgiTarget, EXEC_MODE);
+        if (manifest.daemon) {
+            if (!options.daemonControl)
+                throw new StandaloneBuildError("STANDALONE_DAEMON_ARTIFACT_REQUIRED", "daemon controller artifact required.");
+            copyDaemonPayload(manifest, options.arch, join(staging, "package", "daemon"), options.daemonControl);
+        }
+        if (manifest.integration && !options.helper)
+            throw new StandaloneBuildError("HELPER_ARTIFACT_REQUIRED", "integration SPK 缺少已建置的 helper inventory。");
+        if (options.helper) {
+            const dir = join(staging, "package", "integration");
+            mkdirSync(dir, { recursive: true });
+            copyFileSync(options.helper.binary, join(dir, "helper"));
+            copyFileSync(new URL("../../templates/native-go/backend/THIRD_PARTY_NOTICES.txt", import.meta.url), join(dir, "THIRD_PARTY_NOTICES.txt"));
+            chmodSync(join(dir, "helper"), EXEC_MODE);
+            writeFile(join(dir, "inventory.json"), JSON.stringify(options.helper.inventory));
+            writeFile(join(dir, "workers.json"), JSON.stringify(options.helper.workers.map(({ id, digest }) => ({ id, digest }))));
+            mkdirSync(join(dir, "workers"));
+            for (const worker of options.helper.workers) {
+                writeFileSync(join(dir, "workers", worker.id), worker.bytes, { mode: FILE_MODE });
+            }
+        }
+        if (manifest.integration?.identity === "better-auth") {
+            const source = join(manifest.root, "node", "dist", "app.mjs");
+            const rel = relative(realpathSync(manifest.root), realpathSync(source));
+            if (rel.startsWith("..") || isAbsolute(rel) || !lstatSync(source).isFile() || lstatSync(source).size > 16 * 1024 * 1024)
+                throw new StandaloneBuildError("STANDALONE_IDENTITY_PAYLOAD_INVALID", "Better Auth bundle must be a bounded regular file inside the project.");
+            const target = join(staging, "package", "integration", "identity", "app.mjs");
+            mkdirSync(dirname(target), { recursive: true });
+            copyFileSync(source, target);
+            chmodSync(target, FILE_MODE);
+        }
+        copyStandaloneNotices(manifest.root, manifest.ui.dir, join(staging, 'package'), manifest.backend.kind === 'go' || Boolean(manifest.daemon), Boolean(options.helper), manifest.integration?.identity === 'better-auth', manifest.backend.kind === 'go' ? manifest.backend.dir : undefined);
+        if (manifest.daemon)
+            copyFileSync(new URL('../../templates/_shared/LICENSES/TEMPLATE.txt', import.meta.url), join(staging, 'package', 'LICENSES', 'DAEMON-LICENSE.txt'));
+        const packageTgz = join(staging, "package.tgz");
+        await createReproducibleTar(join(staging, "package"), packageTgz, { gzip: true });
+        rmSync(join(staging, "package"), { recursive: true, force: true });
+        const checksum = createHash("md5").update(readFileSync(packageTgz)).digest("hex");
+        writeFile(join(staging, "INFO"), renderInfo(manifest, options.arch, checksum));
+        mkdirSync(join(staging, "conf"));
+        writeFile(join(staging, "conf", "privilege"), renderNativePrivilege());
+        mkdirSync(join(staging, "scripts"));
+        for (const name of LIFECYCLE_SCRIPTS) {
+            writeFile(join(staging, "scripts", name), renderStandaloneScript(name, manifest), EXEC_MODE);
+        }
+        writePackageCenterIcons(staging);
+        mkdirSync(dirname(options.outputPath), { recursive: true });
+        await createReproducibleTar(staging, options.outputPath);
+    }
+    finally {
+        rmSync(staging, { recursive: true, force: true });
+    }
+}
+function writeFile(path, content, mode = FILE_MODE) {
+    writeFileSync(path, content, "utf8");
+    chmodSync(path, mode);
+}
+function quote(value) {
+    return `"${value}"`;
+}
+/** Manifest validation already refused quotes, backslashes and newlines. */
+function renderInfo(manifest, arch, checksum) {
+    const fields = [
+        ["package", manifest.package],
+        ["version", manifest.spkVersion],
+        ["displayname", manifest.displayname],
+        ["description", manifest.description],
+        ["maintainer", manifest.maintainer],
+        ["arch", infoArchValue(arch)],
+        ["os_min_ver", manifest.os_min_ver],
+        ["dsmuidir", "ui"],
+        ["dsmappname", `SYNO.SDS.${manifest.package}.Instance`],
+        ["thirdparty", "yes"],
+        ["startable", "yes"],
+        ["checksum", checksum],
+    ];
+    if (manifest.integration || manifest.daemon)
+        fields.push(["precheckstartstop", "yes"]);
+    if (manifest.integration?.identity === "better-auth")
+        fields.push(["install_dep_packages", "Node.js_v22"]);
+    for (const locale of LOCALES) {
+        const text = manifest.i18n?.info[locale];
+        if (text?.displayname)
+            fields.push([`displayname_${DSM_LANGS[locale]}`, text.displayname]);
+        if (text?.description)
+            fields.push([`description_${DSM_LANGS[locale]}`, text.description]);
+    }
+    return fields.map(([key, value]) => `${key}=${quote(value)}\n`).join("");
+}
+function copyUiTree(source, target) {
+    for (const entry of ["app.js", "app.css"]) {
+        if (!existsSync(join(source, entry))) {
+            throw new StandaloneBuildError("STANDALONE_UI_ENTRY_MISSING", `UI 目錄缺少 ${entry}：${source}`);
+        }
+    }
+    let total = 0;
+    const walk = (from, to) => {
+        mkdirSync(to, { recursive: true });
+        chmodSync(to, EXEC_MODE);
+        for (const name of readdirSync(from).sort()) {
+            const src = join(from, name);
+            const stat = lstatSync(src);
+            if (stat.isSymbolicLink()) {
+                throw new StandaloneBuildError("STANDALONE_UI_SYMLINK", `UI 目錄不可含 symlink：${src}`);
+            }
+            if (stat.isDirectory()) {
+                walk(src, join(to, name));
+            }
+            else if (stat.isFile()) {
+                total += stat.size;
+                if (total > MAX_UI_BYTES) {
+                    throw new StandaloneBuildError("STANDALONE_UI_TOO_LARGE", "UI 目錄超過 64 MiB。");
+                }
+                copyFileSync(src, join(to, name));
+                chmodSync(join(to, name), FILE_MODE);
+            }
+            else {
+                throw new StandaloneBuildError("STANDALONE_UI_SPECIAL_FILE", `UI 目錄只可含一般檔案與目錄：${src}`);
+            }
+        }
+    };
+    walk(source, target);
+}
+function digestTree(root) {
+    const hash = createHash("sha256");
+    const walk = (dir, prefix) => {
+        for (const name of readdirSync(dir).sort()) {
+            const path = join(dir, name);
+            if (lstatSync(path).isDirectory()) {
+                walk(path, `${prefix}${name}/`);
+            }
+            else {
+                hash.update(`${prefix}${name}\0`).update(readFileSync(path));
+            }
+        }
+    };
+    walk(root, "");
+    return hash.digest("hex");
+}

package/dist/template-paths.d.ts

@@ -0,0 +1,2 @@
+/** Both source execution and the published CLI resolve the same bundled templates. */
+export declare function templatesRoot(): string;

package/dist/template-paths.js

@@ -0,0 +1,9 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Both source execution and the published CLI resolve the same bundled templates. */
+export function templatesRoot() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const distTemplates = join(moduleDir, "templates");
+    return existsSync(distTemplates) ? distTemplates : join(moduleDir, "..", "templates");
+}

package/dist/templates/_daemon/fixture_linux_test.go

@@ -0,0 +1,15 @@
+//go:build linux
+
+package main
+
+import (
+	"os"
+	"os/exec"
+	"syscall"
+)
+
+func dropFixtureUser(cmd *exec.Cmd) {
+	if os.Geteuid() == 0 {
+		cmd.SysProcAttr = &syscall.SysProcAttr{Credential: &syscall.Credential{Uid: 65534, Gid: 65534, Groups: []uint32{65534}}}
+	}
+}

package/dist/templates/_daemon/fixture_other_test.go

@@ -0,0 +1,7 @@
+//go:build !linux
+
+package main
+
+import "os/exec"
+
+func dropFixtureUser(cmd *exec.Cmd) {}

package/dist/templates/_daemon/go.mod

@@ -0,0 +1,3 @@
+module synopkgland-daemon
+
+go 1.24