akm-cli 0.7.5 → 0.8.0-rc.6

package/dist/setup/steps.js

@@ -1,18 +1,6 @@
-/**
- * Composable runner abstraction for `akm setup`.
- *
- * The interactive wizard in `setup.ts` historically ran a fixed series of
- * step functions (`stepStashDir`, `stepOllama`, `stepLlm`, ...) inline.
- * This module formalizes that pattern so steps can be:
- *   - reused by `akm init` (non-interactive preset, see Finding 31),
- *   - tested in isolation by passing a stub `SetupContext`, and
- *   - extended by plugins without touching the wizard call site.
- *
- * Steps mutate state through `SetupContext.apply()`, which accumulates a
- * delta on top of the original config. `stepLlm` reading the embedding
- * endpoint that `stepSemanticSearch` produced is the canonical example of
- * why mutable accumulation is preferred over immutable returns.
- */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * Build a fresh `SetupContext` over a starting config. The returned context
  * applies deltas in-place onto an internal accumulator and exposes the

package/dist/sources/include.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
 import { isWithin } from "../core/common";

package/dist/sources/provider-factory.js

@@ -1,14 +1,7 @@
-/**
- * Source provider factory map.
- *
- * Maps source kind identifiers (e.g. "filesystem", "git", "website", "npm")
- * to factory functions that build {@link SourceProvider} instances from a
- * {@link SourceConfigEntry}.
- *
- * Distinct from the registry-discovery factory (`registry/factory.ts`).
- * Both share `create-provider-registry.ts` for the underlying string→factory
- * map.
- */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { getSources } from "../core/config";
 import { createProviderRegistry } from "../registry/create-provider-registry";
 // ── Factory map ─────────────────────────────────────────────────────────────
 const registry = createProviderRegistry();
@@ -24,7 +17,7 @@ export function resolveSourceProviderFactory(type) {
  */
 export function resolveSourceProviders(config) {
     const providers = [];
-    for (const entry of config.sources ?? config.stashes ?? []) {
+    for (const entry of getSources(config)) {
         if (entry.enabled === false)
             continue;
         const factory = registry.resolve(entry.type);

package/dist/sources/provider.js

@@ -1,21 +1,4 @@
-/**
- * SourceProvider — minimal v1 interface (spec §2.1).
- *
- * A SourceProvider gets files into a directory. The indexer walks `path()`
- * and reads files from disk. Search and show go through the indexer, not
- * through provider methods.
- *
- * Three required members + one optional:
- *   - name      configured source name
- *   - kind      "filesystem" | "git" | "website" | "npm"
- *   - init(ctx) called once after construction
- *   - path()    the directory the indexer walks (stable for instance lifetime)
- *   - sync?()   refresh the directory from upstream (no-op for filesystem)
- *
- * All other writing/reading concerns live outside this interface:
- *   - Writes:    src/core/write-source.ts (Phase 5)
- *   - Reads:     src/indexer.ts (Phase 4)
- *   - Install:   src/sources/providers/sync-from-ref.ts (install-time helpers,
- *                separate from configured-source plumbing)
- */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 export {};

package/dist/sources/providers/filesystem.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { resolveStashDir } from "../../core/common";
 import { ConfigError } from "../../core/errors";
 import { registerSourceProvider } from "../provider-factory";
@@ -8,28 +11,21 @@ import { registerSourceProvider } from "../provider-factory";
  * just `{ name, kind, init, path }`. No `sync()` — content is the user's
  * own directory, never refreshed by akm.
  */
-class FilesystemSourceProvider {
-    kind = "filesystem";
-    name;
-    #stashDir;
-    constructor(entry) {
-        if (entry.type !== "filesystem") {
-            throw new ConfigError(`FilesystemSourceProvider invoked with type="${entry.type}"`);
-        }
-        this.#stashDir = entry.path ?? resolveStashDir();
-        if (!this.#stashDir) {
-            throw new ConfigError("filesystem source requires a `path`");
-        }
-        this.name = entry.name ?? this.#stashDir;
+registerSourceProvider("filesystem", (entry) => {
+    if (entry.type !== "filesystem") {
+        throw new ConfigError(`filesystem source invoked with type="${entry.type}"`);
     }
-    async init(_ctx) {
-        // Filesystem sources resolve their path eagerly in the constructor;
-        // init has nothing to do beyond letting the registry know we're ready.
+    const stashDir = entry.path ?? resolveStashDir();
+    if (!stashDir) {
+        throw new ConfigError("filesystem source requires a `path`");
     }
-    path() {
-        return this.#stashDir;
-    }
-}
-// ── Self-register ───────────────────────────────────────────────────────────
-registerSourceProvider("filesystem", (config) => new FilesystemSourceProvider(config));
-export { FilesystemSourceProvider };
+    const name = entry.name ?? stashDir;
+    return {
+        kind: "filesystem",
+        name,
+        async init(_ctx) { },
+        path() {
+            return stashDir;
+        },
+    };
+});

package/dist/sources/providers/git.js

@@ -1,10 +1,13 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { TYPE_DIRS } from "../../core/asset-spec";
 import { resolveStashDir } from "../../core/common";
-import { loadConfig } from "../../core/config";
+import { getSources, loadConfig } from "../../core/config";
 import { ConfigError, UsageError } from "../../core/errors";
 import { getRegistryCacheDir, getRegistryIndexCacheDir } from "../../core/paths";
 import { sanitizeCommitMessage } from "../../core/write-source";
@@ -15,7 +18,6 @@ import { applyAkmIncludeConfig, buildInstallCacheDir, copyDirectoryContents, det
 const CACHE_TTL_MS = 12 * 60 * 60 * 1000;
 /** Maximum stale age allowed when refresh fails (7 days). */
 const CACHE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
-const GIT_STASH_TYPES = new Set(["git"]);
 /**
  * Git source provider — clones (and re-pulls) a remote repo into a local
  * cache directory. Implements the v1 {@link SourceProvider} interface (spec
@@ -407,10 +409,10 @@ export function saveGitStash(name, message, writableOverride) {
     let writable = false;
     if (name) {
         const config = loadConfig();
-        const stash = findGitStashByTarget(config.sources ?? config.stashes ?? [], name);
+        const stash = findGitStashByTarget(getSources(config), name);
         if (!stash)
             throw new UsageError(`No git stash found with name "${name}"`);
-        if (!GIT_STASH_TYPES.has(stash.type)) {
+        if (stash.type !== "git") {
             throw new UsageError(`Stash "${name}" is not a git stash (type: ${stash.type})`);
         }
         if (!stash.url)
@@ -472,7 +474,7 @@ function findGitStashByTarget(stashes, target) {
     return stashes.find((stash) => matchesGitStashTarget(stash, target));
 }
 function matchesGitStashTarget(stash, target) {
-    if (!GIT_STASH_TYPES.has(stash.type))
+    if (stash.type !== "git")
         return false;
     if (stash.name === target || stash.url === target)
         return true;

package/dist/sources/providers/index.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * Centralized source provider registration.
  *

package/dist/sources/providers/install-types.js

@@ -1,14 +1,4 @@
-/**
- * Install-time types used by `syncFromRef` and the legacy install pipeline.
- *
- * Distinct from the v1 {@link SourceProvider} interface (which only deals
- * with "configured sources" — entries already resolved into a directory).
- * These types describe the resolution+lockfile step that runs when
- * `akm add <install-ref>` materialises an upstream artifact into a local
- * cache directory.
- *
- * They live here, outside `provider.ts`, so the v1 SourceProvider
- * interface stays minimal (`{ name, kind, init, path, sync? }`) per the
- * architecture spec §2.1.
- */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 export {};

package/dist/sources/providers/npm.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * Npm-source stash provider.
  *
@@ -5,10 +8,6 @@
  * integrity, extracts it securely (via `extractTarGzSecure`), detects the
  * stash root inside the package, and applies any nested `.akm-include`
  * configuration. Cache hits short-circuit the fetch.
- *
- * Audit is intentionally NOT performed here — `akmAdd` calls
- * `auditInstallCandidate` after `sync()` so the policy decision lives at
- * the orchestrator layer where the `--trust` flag is known.
  */
 import fs from "node:fs";
 import path from "node:path";

package/dist/sources/providers/provider-utils.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";

package/dist/sources/providers/sync-from-ref.js

@@ -1,14 +1,6 @@
-/**
- * Unified install-ref dispatcher.
- *
- * Replaces the historical `installRegistryRef()` entry point. Given an
- * unparsed install ref, this resolves the right syncable provider and
- * invokes its `sync()` method.
- *
- * Audit is intentionally NOT performed here; callers (`akmAdd`,
- * `akmUpdate`) decide whether to run `auditInstallCandidate` on the
- * synced `contentDir` because they own the `--trust` flag.
- */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { UsageError } from "../../core/errors";
 import { parseRegistryRef } from "../../registry/resolve";
 import { detectStashRoot } from "./provider-utils";

package/dist/sources/providers/tar-utils.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * Tar archive extraction and integrity verification utilities.
  *

package/dist/sources/providers/website.js

@@ -1,27 +1,23 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { registerSourceProvider } from "../provider-factory";
 import { ensureWebsiteMirror, getWebsiteCachePaths, validateWebsiteUrl } from "../website-ingest";
 /**
  * Website source provider — thin adapter over the shared website ingest module.
  */
-class WebsiteSourceProvider {
-    kind = "website";
-    name;
-    #config;
-    #url;
-    constructor(config) {
-        this.#config = config;
-        this.name = config.name ?? "website";
-        this.#url = validateWebsiteUrl(config.url ?? "");
-    }
-    async init(_ctx) {
-        // URL validation already happens in the constructor; nothing else to do.
-    }
-    path() {
-        return getWebsiteCachePaths(this.#url).stashDir;
-    }
-    async sync() {
-        await ensureWebsiteMirror(this.#config, { requireStashDir: true });
-    }
-}
-registerSourceProvider("website", (config) => new WebsiteSourceProvider(config));
-export { WebsiteSourceProvider };
+registerSourceProvider("website", (config) => {
+    const url = validateWebsiteUrl(config.url ?? "");
+    const name = config.name ?? "website";
+    return {
+        kind: "website",
+        name,
+        async init(_ctx) { },
+        path() {
+            return getWebsiteCachePaths(url).stashDir;
+        },
+        async sync() {
+            await ensureWebsiteMirror(config, { requireStashDir: true });
+        },
+    };
+});

package/dist/sources/resolve.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
 import { deriveCanonicalAssetNameFromStashRoot, isRelevantAssetFile, resolveAssetPathFromName, TYPE_DIRS, } from "../core/asset-spec";

package/dist/sources/types.js

@@ -1 +1,4 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 export {};

package/dist/sources/website-ingest.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
@@ -167,6 +170,10 @@ async function crawlWebsite(startUrl, options) {
     return pages;
 }
 async function fetchWebsitePage(pageUrl) {
+    const parsedUrl = new URL(pageUrl);
+    if (parsedUrl.hostname.endsWith(".invalid")) {
+        throw new Error(`Refusing to fetch reserved invalid hostname: ${parsedUrl.hostname}`);
+    }
     const response = await fetchWithRetry(pageUrl, {
         headers: {
             Accept: "text/html, text/markdown, text/plain;q=0.9, application/xhtml+xml;q=0.8",

package/dist/tasks/backends/cron.js

@@ -0,0 +1,203 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+// crontab backend for `akm tasks` (Linux default).
+//
+// Each akm-owned entry is wrapped in markers so a hand-edited crontab keeps
+// its other lines untouched:
+//
+//     # akm:task <id> BEGIN
+//     [SCHED] /abs/akm tasks run <id> >> /home/.../tasks/logs/<id>.log 2>&1
+//     # akm:task <id> END
+//
+// The backend reads/writes the user's crontab via `crontab -l` and
+// `crontab -`. Disabling a task comments the entry with `# akm:disabled `
+// rather than removing it, so re-enabling preserves the original schedule.
+//
+// Platform notes:
+//   • Operates on the *per-user* crontab — system-wide /etc/cron.d entries
+//     are out of scope.
+//   • Cron runs jobs with a stripped environment (`SHELL`, `PATH`, `HOME`,
+//     `LOGNAME`/`USER` only). The cron line uses an absolute akm path
+//     resolved at install time so it doesn't rely on the inherited PATH.
+//   • BSD `crontab -l` returns exit 1 with "no crontab for <user>" on a
+//     fresh user; we treat that as an empty crontab rather than an error.
+//
+// Tests inject a fake exec so unit tests don't touch the real crontab.
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { ConfigError } from "../../core/errors";
+import { getTaskLogDir } from "../../core/paths";
+import { resolveAkmInvocation } from "../resolveAkmBin";
+import { parseSchedule, translateToCron } from "../schedule";
+const BEGIN = (id) => `# akm:task ${id} BEGIN`;
+const END = (id) => `# akm:task ${id} END`;
+const DISABLED_PREFIX = "# akm:disabled ";
+const BLOCK_RE = /^# akm:task ([\w.@:_-]+) BEGIN$/;
+export function CRON_BACKEND(options = {}) {
+    const exec = options.exec ?? defaultCronExec();
+    const logDir = options.logDir ?? getTaskLogDir();
+    const akmArgv = options.akmArgv ?? resolveAkmInvocation().argv;
+    return {
+        name: "cron",
+        install(task) {
+            // Create the log directory before writing the crontab line — cron
+            // appends with `>>` and the surrounding shell will fail the entire
+            // entry if the parent directory doesn't exist.
+            ensureDir(logDir);
+            const cronLine = buildCronLine(task, akmArgv, logDir);
+            const existing = readCrontab(exec);
+            const block = renderBlock(task.id, cronLine, task.enabled);
+            const next = upsertBlock(existing, task.id, block);
+            writeCrontab(exec, next);
+        },
+        uninstall(id) {
+            const existing = readCrontab(exec);
+            const next = removeBlock(existing, id);
+            writeCrontab(exec, next);
+        },
+        setEnabled(id, enabled) {
+            const existing = readCrontab(exec);
+            const next = toggleBlock(existing, id, enabled);
+            writeCrontab(exec, next);
+        },
+        list() {
+            const existing = readCrontab(exec);
+            const ids = [];
+            for (const line of existing.split(/\r?\n/)) {
+                const m = line.match(BLOCK_RE);
+                if (m)
+                    ids.push(m[1]);
+            }
+            return ids.map((id) => ({ id }));
+        },
+    };
+}
+// ── helpers (exported for tests) ────────────────────────────────────────────
+export function buildCronLine(task, akmArgv, logDir) {
+    const spec = parseSchedule(task.schedule, "cron");
+    const cronExpr = translateToCron(spec);
+    const logPath = path.join(logDir, `${task.id}.log`);
+    const cmd = [...akmArgv, "tasks", "run", task.id].map((part) => quoteForCron(part)).join(" ");
+    return `${cronExpr} ${cmd} >> ${quoteForCron(logPath)} 2>&1`;
+}
+export function renderBlock(id, cronLine, enabled) {
+    const body = enabled ? cronLine : `${DISABLED_PREFIX}${cronLine}`;
+    return [BEGIN(id), body, END(id)].join("\n");
+}
+export function upsertBlock(existing, id, block) {
+    const trimmed = existing.replace(/\s+$/g, "");
+    const removed = removeBlock(trimmed, id);
+    const sep = removed.length === 0 ? "" : "\n";
+    return `${removed}${sep}${block}\n`;
+}
+export function removeBlock(existing, id) {
+    const lines = existing.split(/\r?\n/);
+    const out = [];
+    let inBlock = false;
+    for (const line of lines) {
+        if (!inBlock && line === BEGIN(id)) {
+            inBlock = true;
+            continue;
+        }
+        if (inBlock && line === END(id)) {
+            inBlock = false;
+            continue;
+        }
+        if (inBlock)
+            continue;
+        out.push(line);
+    }
+    // Collapse trailing blank lines.
+    while (out.length > 0 && out[out.length - 1] === "")
+        out.pop();
+    return out.join("\n");
+}
+export function toggleBlock(existing, id, enabled) {
+    const lines = existing.split(/\r?\n/);
+    const out = [];
+    let inBlock = false;
+    for (const line of lines) {
+        if (!inBlock && line === BEGIN(id)) {
+            inBlock = true;
+            out.push(line);
+            continue;
+        }
+        if (inBlock && line === END(id)) {
+            inBlock = false;
+            out.push(line);
+            continue;
+        }
+        if (inBlock) {
+            const isComment = line.startsWith(DISABLED_PREFIX);
+            if (enabled && isComment) {
+                out.push(line.slice(DISABLED_PREFIX.length));
+            }
+            else if (!enabled && !isComment) {
+                out.push(`${DISABLED_PREFIX}${line}`);
+            }
+            else {
+                out.push(line);
+            }
+            continue;
+        }
+        out.push(line);
+    }
+    return out.join("\n");
+}
+function quoteForCron(part) {
+    // crontab passes the rest of the line to /bin/sh -c, so quote anything that
+    // isn't a plain shell-safe token. Single-quote and escape embedded single
+    // quotes via the standard shell idiom: `'foo'\''bar'`.
+    if (/^[A-Za-z0-9_\-./@:%=+,]+$/.test(part))
+        return part;
+    return `'${part.replace(/'/g, `'\\''`)}'`;
+}
+function readCrontab(exec) {
+    const result = exec.read();
+    if (result.status === 0)
+        return result.stdout ?? "";
+    // BSD crontab returns 1 with "no crontab for <user>" on stderr — treat as empty.
+    if (/no crontab for/i.test(result.stderr ?? ""))
+        return "";
+    if (/no crontab/i.test(result.stdout ?? ""))
+        return "";
+    throw new ConfigError(`crontab -l failed (exit ${result.status}): ${result.stderr || result.stdout || "no output"}.`, "INVALID_CONFIG_FILE", "Ensure the `crontab` binary is on PATH and your shell can read the user crontab.");
+}
+function writeCrontab(exec, content) {
+    const normalised = content.endsWith("\n") || content.length === 0 ? content : `${content}\n`;
+    const result = exec.write(normalised);
+    if (result.status !== 0) {
+        throw new ConfigError(`crontab - failed (exit ${result.status}): ${result.stderr || result.stdout || "no output"}.`, "INVALID_CONFIG_FILE", "Ensure the `crontab` binary is on PATH and your shell can write the user crontab.");
+    }
+}
+function ensureDir(dir) {
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch {
+        // Best-effort: the install will surface a clearer error if the cron
+        // line later fails at runtime due to a missing redirection target.
+    }
+}
+function defaultCronExec() {
+    return {
+        read() {
+            const r = spawnSync("crontab", ["-l"], { encoding: "utf8" });
+            return {
+                status: r.status ?? 1,
+                stdout: r.stdout ?? "",
+                stderr: r.stderr ?? "",
+            };
+        },
+        write(content) {
+            const r = spawnSync("crontab", ["-"], { encoding: "utf8", input: content });
+            return {
+                status: r.status ?? 1,
+                stdout: r.stdout ?? "",
+                stderr: r.stderr ?? "",
+            };
+        },
+    };
+}

package/dist/tasks/backends/exec-utils.js

@@ -0,0 +1,28 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { spawnSync } from "node:child_process";
+/**
+ * Run a command synchronously, normalizing null results to safe defaults.
+ * args[0] is the binary; args[1..] are its arguments.
+ */
+export function spawnCommand(args) {
+    const [bin, ...rest] = args;
+    const r = spawnSync(bin, rest, { encoding: "utf8" });
+    return {
+        status: r.status ?? 1,
+        stdout: r.stdout ?? "",
+        stderr: r.stderr ?? "",
+    };
+}
+/**
+ * Escape a string for safe embedding in an XML attribute or text node.
+ */
+export function escapeXml(s) {
+    return s
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}

package/dist/tasks/backends/index.js

@@ -0,0 +1,24 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { CRON_BACKEND } from "./cron";
+import { LAUNCHD_BACKEND } from "./launchd";
+import { SCHTASKS_BACKEND } from "./schtasks";
+export function selectBackend(options = {}) {
+    const platform = options.platform ?? process.platform;
+    switch (platform) {
+        case "win32":
+            return SCHTASKS_BACKEND(options.schtasks);
+        case "darwin":
+            return LAUNCHD_BACKEND(options.launchd);
+        default:
+            return CRON_BACKEND(options.cron);
+    }
+}
+export function backendNameForPlatform(platform = process.platform) {
+    if (platform === "win32")
+        return "schtasks";
+    if (platform === "darwin")
+        return "launchd";
+    return "cron";
+}

package/dist/tasks/backends/launchd-template.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>{{LABEL}}</string>
+  <key>ProgramArguments</key>
+  <array>
+{{PROGRAM_ARGS}}
+  </array>
+  <key>StandardOutPath</key>
+  <string>{{LOG_PATH}}</string>
+  <key>StandardErrorPath</key>
+  <string>{{LOG_PATH}}</string>
+  <key>RunAtLoad</key>
+  <false/>
+{{ENV_VARS}}{{TRIGGER_XML}}
+</dict>
+</plist>