loadout-ai 0.1.0

package/dist/src/core/sandbox.js

@@ -0,0 +1,78 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { resolve } from "node:path";
+const execFileAsync = promisify(execFile);
+/**
+ * Run an explicitly approved command in a disposable local Docker container.
+ * Source is mounted read-only; no host environment, socket, network, or
+ * writable source path is exposed. This executes nothing unless approveRisk is
+ * true and the caller supplies an image they have reviewed/pinned.
+ */
+export async function runDisposableSandbox(options) {
+    if (!options.approveRisk)
+        throw new Error("Sandbox execution requires explicit --approve-risk");
+    if (!options.image.trim() || /\s/.test(options.image))
+        throw new Error("Sandbox image must be one reviewed image reference");
+    if (!options.command.length || options.command.some((item) => !item.trim()))
+        throw new Error("Sandbox command must contain at least one non-empty argument");
+    const sourceDirectory = resolve(options.sourceDirectory);
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 1_000 || timeoutMs > 900_000)
+        throw new Error("Sandbox timeout must be between 1000ms and 900000ms");
+    const args = [
+        "run",
+        "--rm",
+        "--network",
+        "none",
+        "--read-only",
+        "--tmpfs",
+        "/tmp:rw,noexec,nosuid,size=64m",
+        "--cap-drop",
+        "ALL",
+        "--security-opt",
+        "no-new-privileges",
+        "--pids-limit",
+        "128",
+        "--memory",
+        "512m",
+        "--cpus",
+        "1",
+        "--user",
+        "65532:65532",
+        "--mount",
+        `type=bind,src=${sourceDirectory},dst=/input,readonly`,
+        options.image,
+        ...options.command,
+    ];
+    const runner = options.runner ??
+        (async (dockerArgs, timeout) => {
+            try {
+                const result = await execFileAsync("docker", dockerArgs, {
+                    timeout,
+                    windowsHide: true,
+                    // Deliberately do not spread process.env into an untrusted process.
+                    env: { PATH: process.env.PATH ?? "/usr/bin:/bin" },
+                    maxBuffer: 2 * 1024 * 1024,
+                });
+                return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
+            }
+            catch (error) {
+                const result = error;
+                if (result.killed)
+                    throw new Error(`Sandbox timed out after ${timeout}ms`);
+                return {
+                    stdout: result.stdout ?? "",
+                    stderr: result.stderr ?? String(error),
+                    exitCode: typeof result.code === "number" ? result.code : 1,
+                };
+            }
+        });
+    const result = await runner(args, timeoutMs);
+    return {
+        image: options.image,
+        command: options.command,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+    };
+}

package/dist/src/core/scheduler.js

@@ -0,0 +1,264 @@
+import { execFile } from "node:child_process";
+import { rm } from "node:fs/promises";
+import { dirname, win32, join } from "node:path";
+import { promisify } from "node:util";
+import { writeFileAtomically } from "./atomic-file.js";
+import { ensureDirectory, loadoutHome, userHome } from "./paths.js";
+import { createSnapshot } from "./snapshot.js";
+import { beginTransaction, completeTransaction, markTransactionCommitting, recoverPendingTransactions, rollbackTransaction, } from "./transaction.js";
+const execFileAsync = promisify(execFile);
+function parseTime(value) {
+    const match = /^(\d{2}):(\d{2})$/.exec(value);
+    const hour = Number(match?.[1]);
+    const minute = Number(match?.[2]);
+    if (!match || hour > 23 || minute > 59)
+        throw new Error("--time must use 24-hour HH:MM");
+    return { hour, minute, text: value };
+}
+function xml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function systemd(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+export function planNativeScheduler(action, options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (!["darwin", "linux", "win32"].includes(platform))
+        throw new Error(`Native scheduling is unsupported on '${platform}'. Supported: macOS, Windows, Linux.`);
+    const selectedPlatform = platform;
+    const time = parseTime(options.time ?? "09:00");
+    const home = options.home ?? userHome(process.env, platform);
+    const stateHome = options.stateHome ?? loadoutHome(process.env, platform);
+    const nodePath = options.nodePath ?? process.execPath;
+    const cliPath = options.cliPath ?? process.argv[1];
+    const launcher = options.launcher ?? [nodePath, cliPath];
+    if (!launcher.length || launcher.some((item) => !item))
+        throw new Error("Scheduler launcher arguments must be non-empty");
+    const job = options.job ?? "updates";
+    const nativeId = `loadout-daily-${job}`;
+    const command = job === "updates"
+        ? [...launcher, "watch", "--once", "--json"]
+        : [...launcher, "discover", "--source", "all", "--queue", "--json"];
+    if (selectedPlatform === "darwin") {
+        const label = `com.loadout.daily.${job}`;
+        const path = join(home, "Library", "LaunchAgents", `${label}.plist`);
+        const log = join(stateHome, "logs", `daily-${job}.log`);
+        const content = `<?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>${command.map((item) => `<string>${xml(item)}</string>`).join("")}</array>
+<key>StartCalendarInterval</key><dict><key>Hour</key><integer>${time.hour}</integer><key>Minute</key><integer>${time.minute}</integer></dict>
+<key>ProcessType</key><string>Background</string>
+<key>StandardOutPath</key><string>${xml(log)}</string>
+<key>StandardErrorPath</key><string>${xml(log)}</string>
+</dict></plist>
+`;
+        const domain = `gui/${options.uid ?? process.getuid?.() ?? 0}`;
+        return {
+            action,
+            job,
+            platform: selectedPlatform,
+            time: time.text,
+            command,
+            directories: [join(stateHome, "logs")],
+            files: [{ path, content }],
+            applyCommands: action === "schedule"
+                ? [
+                    {
+                        command: "launchctl",
+                        args: ["bootout", domain, path],
+                        allowFailure: true,
+                    },
+                    { command: "launchctl", args: ["bootstrap", domain, path] },
+                ]
+                : [
+                    {
+                        command: "launchctl",
+                        args: ["bootout", domain, path],
+                        allowFailure: true,
+                    },
+                ],
+            rollbackCommands: action === "schedule"
+                ? [{ command: "launchctl", args: ["bootout", domain, path] }]
+                : [],
+            guarantee: "read-only-checks-only",
+        };
+    }
+    if (selectedPlatform === "linux") {
+        const service = join(home, ".config", "systemd", "user", `${nativeId}.service`);
+        const timer = join(home, ".config", "systemd", "user", `${nativeId}.timer`);
+        return {
+            action,
+            job,
+            platform: selectedPlatform,
+            time: time.text,
+            command,
+            directories: [],
+            files: [
+                {
+                    path: service,
+                    content: `[Unit]
+Description=Loadout read-only ${job === "updates" ? "update check" : "candidate discovery"}
+
+[Service]
+Type=oneshot
+ExecStart=${command.map(systemd).join(" ")}
+`,
+                },
+                {
+                    path: timer,
+                    content: `[Unit]
+Description=Daily Loadout read-only ${job === "updates" ? "update check" : "candidate discovery"}
+
+[Timer]
+OnCalendar=*-*-* ${time.text}:00
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`,
+                },
+            ],
+            applyCommands: action === "schedule"
+                ? [
+                    { command: "systemctl", args: ["--user", "daemon-reload"] },
+                    {
+                        command: "systemctl",
+                        args: ["--user", "enable", "--now", `${nativeId}.timer`],
+                    },
+                ]
+                : [
+                    {
+                        command: "systemctl",
+                        args: ["--user", "disable", "--now", `${nativeId}.timer`],
+                        allowFailure: true,
+                    },
+                    { command: "systemctl", args: ["--user", "daemon-reload"] },
+                ],
+            rollbackCommands: action === "schedule"
+                ? [
+                    {
+                        command: "systemctl",
+                        args: ["--user", "disable", "--now", `${nativeId}.timer`],
+                    },
+                ]
+                : [],
+            guarantee: "read-only-checks-only",
+        };
+    }
+    const path = win32.join(stateHome, "scheduler", `${nativeId}.xml`);
+    const taskName = `LoadoutDaily${job === "updates" ? "Updates" : "Discovery"}`;
+    const argumentsValue = command
+        .slice(1)
+        .map((item) => `"${item.replace(/"/g, '\\"')}"`)
+        .join(" ");
+    const content = `<?xml version="1.0" encoding="UTF-8"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+<Triggers><CalendarTrigger><StartBoundary>2000-01-01T${time.text}:00</StartBoundary><Enabled>true</Enabled><ScheduleByDay><DaysInterval>1</DaysInterval></ScheduleByDay></CalendarTrigger></Triggers>
+<Principals><Principal id="Author"><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal></Principals>
+<Settings><MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy><StartWhenAvailable>true</StartWhenAvailable><ExecutionTimeLimit>PT10M</ExecutionTimeLimit></Settings>
+<Actions Context="Author"><Exec><Command>${xml(command[0])}</Command><Arguments>${xml(argumentsValue)}</Arguments></Exec></Actions>
+</Task>
+`;
+    return {
+        action,
+        job,
+        platform: selectedPlatform,
+        time: time.text,
+        command,
+        directories: [],
+        files: [{ path, content }],
+        applyCommands: action === "schedule"
+            ? [
+                {
+                    command: "schtasks",
+                    args: ["/Create", "/TN", taskName, "/XML", path, "/F"],
+                },
+            ]
+            : [
+                {
+                    command: "schtasks",
+                    args: ["/Delete", "/TN", taskName, "/F"],
+                    allowFailure: true,
+                },
+            ],
+        rollbackCommands: action === "schedule"
+            ? [
+                {
+                    command: "schtasks",
+                    args: ["/Delete", "/TN", taskName, "/F"],
+                },
+            ]
+            : [],
+        guarantee: "read-only-checks-only",
+    };
+}
+const defaultRunner = async (command, args) => {
+    await execFileAsync(command, args);
+};
+export async function applyNativeScheduler(plan, runner = defaultRunner) {
+    return applyNativeSchedulerBundle([plan], runner);
+}
+/** Apply both read-only daily jobs through one filesystem transaction. */
+export async function applyNativeSchedulerBundle(plans, runner = defaultRunner) {
+    if (!plans.length)
+        throw new Error("At least one scheduler plan is required");
+    const actions = new Set(plans.map((plan) => plan.action));
+    if (actions.size !== 1)
+        throw new Error("A scheduler bundle cannot mix schedule and unschedule plans");
+    await recoverPendingTransactions();
+    const paths = [
+        ...new Set(plans.flatMap((plan) => plan.files.map((file) => file.path))),
+    ];
+    const snapshot = await createSnapshot(paths, { persist: false });
+    const transaction = await beginTransaction(snapshot, paths);
+    try {
+        await markTransactionCommitting(transaction);
+        if (plans[0].action === "schedule") {
+            for (const directory of new Set(plans.flatMap((plan) => plan.directories)))
+                await ensureDirectory(directory);
+            for (const file of plans.flatMap((plan) => plan.files)) {
+                await ensureDirectory(dirname(file.path));
+                await writeFileAtomically(file.path, file.content);
+            }
+        }
+        for (const item of plans.flatMap((plan) => plan.applyCommands))
+            try {
+                await runner(item.command, item.args);
+            }
+            catch (error) {
+                if (!item.allowFailure)
+                    throw error;
+            }
+        if (plans[0].action === "unschedule")
+            for (const file of plans.flatMap((plan) => plan.files))
+                await rm(file.path, { force: true });
+        await completeTransaction(transaction);
+    }
+    catch (error) {
+        for (const item of plans.flatMap((plan) => plan.rollbackCommands).reverse())
+            try {
+                await runner(item.command, item.args);
+            }
+            catch {
+                /* filesystem/state rollback remains authoritative */
+            }
+        await rollbackTransaction(transaction);
+        throw error;
+    }
+    return snapshot.id;
+}
+export function formatNativeScheduler(plan) {
+    return [
+        `${plan.action === "schedule" ? "Schedule" : "Unschedule"} daily read-only ${plan.job === "updates" ? "update check" : "candidate discovery"} — ${plan.platform} at ${plan.time}`,
+        `Command: ${plan.command.join(" ")}`,
+        ...plan.files.map((file) => `File: ${file.path}`),
+        ...plan.applyCommands.map((item) => `Native action: ${item.command} ${item.args.join(" ")}`),
+        `Guarantee: the scheduled command is ${plan.command.slice(2).join(" ")}; it can only report updates or queue candidates and cannot apply changes.`,
+    ].join("\n");
+}

package/dist/src/core/share-report.js

@@ -0,0 +1,85 @@
+import { dirname } from "node:path";
+import { writeFileAtomically } from "./atomic-file.js";
+import { ensureDirectory } from "./paths.js";
+import { readInstallState } from "./state.js";
+export function parsePrivacySafeLoadoutReport(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Privacy-safe Loadout report must be an object");
+    const report = value;
+    if (report.schemaVersion !== 1 ||
+        typeof report.generatedAt !== "string" ||
+        !Number.isFinite(Date.parse(report.generatedAt)) ||
+        !Array.isArray(report.packages) ||
+        !Array.isArray(report.mcp) ||
+        !report.privacy ||
+        !Array.isArray(report.privacy.excludes))
+        throw new Error("Privacy-safe Loadout report schema is invalid");
+    for (const item of report.packages) {
+        if (!item ||
+            typeof item !== "object" ||
+            typeof item.id !== "string" ||
+            !Array.isArray(item.agents) ||
+            !item.agents.every((agent) => typeof agent === "string") ||
+            ![
+                item.managedFiles,
+                item.activeSkills,
+                item.disabledSkills,
+                item.reviewedSkills,
+                item.unreviewedSkills,
+            ].every((count) => Number.isSafeInteger(count) && count >= 0))
+            throw new Error("Privacy-safe Loadout package entry is invalid");
+    }
+    if (!report.mcp.every((item) => item && typeof item === "object" && typeof item.packageId === "string") ||
+        !report.privacy.excludes.every((item) => typeof item === "string"))
+        throw new Error("Privacy-safe Loadout report entry is invalid");
+    return report;
+}
+export async function buildPrivacySafeReport() {
+    const state = await readInstallState();
+    return {
+        schemaVersion: 1,
+        generatedAt: new Date().toISOString(),
+        packages: state.installs
+            .map((install) => {
+            const activations = (state.activations ?? []).filter((item) => item.packageId === install.packageId);
+            return {
+                id: install.packageId,
+                ...(install.resolvedCommit ? { commit: install.resolvedCommit } : {}),
+                agents: [...install.targetAgents].sort(),
+                managedFiles: install.files.length,
+                activeSkills: activations.filter((item) => item.activationState === "active").length,
+                disabledSkills: activations.filter((item) => item.activationState === "disabled").length,
+                reviewedSkills: activations.filter((item) => item.reviewState === "reviewed").length,
+                unreviewedSkills: activations.filter((item) => item.reviewState !== "reviewed").length,
+            };
+        })
+            .sort((left, right) => left.id.localeCompare(right.id)),
+        mcp: (state.mcpInstalls ?? [])
+            .map((item) => ({ packageId: item.packageId }))
+            .filter((item, index, values) => values.findIndex((candidate) => candidate.packageId === item.packageId) === index)
+            .sort((left, right) => left.packageId.localeCompare(right.packageId)),
+        privacy: {
+            excludes: [
+                "usernames",
+                "absolute paths",
+                "project names",
+                "repository names",
+                "prompts",
+                "source code",
+                "filenames",
+                "credential values",
+            ],
+        },
+    };
+}
+export async function writePrivacySafeReport(path, report) {
+    await ensureDirectory(dirname(path));
+    await writeFileAtomically(path, `${JSON.stringify(report, null, 2)}\n`);
+}
+export function formatPrivacySafeReport(report) {
+    return [
+        `Shareable Loadout report: ${report.packages.length} package(s), ${report.mcp.length} MCP entry/entries`,
+        ...report.packages.map((item) => `${item.id} — ${item.commit?.slice(0, 12) ?? "local"} — agents:${item.agents.join(",")} — skills:${item.activeSkills} active/${item.disabledSkills} disabled`),
+        "Privacy: no local paths, project names, source filenames/content, prompts, or credential values.",
+    ].join("\n");
+}

package/dist/src/core/signing.js

@@ -0,0 +1,115 @@
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify, } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+function canonical(value) {
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "number" ||
+        typeof value === "string")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (typeof value === "object")
+        return `{${Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`)
+            .join(",")}}`;
+    throw new Error(`Cannot sign unsupported value type: ${typeof value}`);
+}
+function fingerprint(publicKey) {
+    return `sha256:${createHash("sha256")
+        .update(publicKey.export({ type: "spki", format: "der" }))
+        .digest("hex")}`;
+}
+export function publicKeyFingerprint(publicKeyPem) {
+    const publicKey = createPublicKey(publicKeyPem);
+    if (publicKey.asymmetricKeyType !== "ed25519")
+        throw new Error("Signing public key must be Ed25519");
+    return fingerprint(publicKey);
+}
+export function signPayload(payload, privateKeyPem, createdAt = new Date().toISOString()) {
+    const privateKey = createPrivateKey(privateKeyPem);
+    const publicKey = createPublicKey(privateKey);
+    if (privateKey.asymmetricKeyType !== "ed25519")
+        throw new Error("Signing key must be Ed25519");
+    const message = Buffer.from(canonical({
+        schemaVersion: 1,
+        algorithm: "Ed25519",
+        createdAt,
+        publicKeyFingerprint: fingerprint(publicKey),
+        payload,
+    }));
+    return {
+        schemaVersion: 1,
+        algorithm: "Ed25519",
+        createdAt,
+        publicKeyFingerprint: fingerprint(publicKey),
+        payload,
+        signature: sign(null, message, privateKey).toString("base64"),
+    };
+}
+export function verifyEnvelope(envelope, publicKeyPem) {
+    if (envelope.schemaVersion !== 1 ||
+        envelope.algorithm !== "Ed25519" ||
+        typeof envelope.signature !== "string")
+        return { valid: false, fingerprint: "invalid" };
+    const publicKey = createPublicKey(publicKeyPem);
+    const keyFingerprint = fingerprint(publicKey);
+    if (publicKey.asymmetricKeyType !== "ed25519")
+        return { valid: false, fingerprint: keyFingerprint };
+    if (envelope.publicKeyFingerprint !== keyFingerprint)
+        return { valid: false, fingerprint: keyFingerprint };
+    const message = Buffer.from(canonical({
+        schemaVersion: envelope.schemaVersion,
+        algorithm: envelope.algorithm,
+        createdAt: envelope.createdAt,
+        publicKeyFingerprint: envelope.publicKeyFingerprint,
+        payload: envelope.payload,
+    }));
+    let signature;
+    try {
+        signature = Buffer.from(envelope.signature, "base64");
+    }
+    catch {
+        return { valid: false, fingerprint: keyFingerprint };
+    }
+    return {
+        valid: verify(null, message, publicKey, signature),
+        fingerprint: keyFingerprint,
+    };
+}
+export async function generateSigningKeys(privatePath, publicPath) {
+    const pair = generateKeyPairSync("ed25519");
+    const privatePem = pair.privateKey
+        .export({ type: "pkcs8", format: "pem" })
+        .toString();
+    const publicPem = pair.publicKey
+        .export({ type: "spki", format: "pem" })
+        .toString();
+    const privateKey = resolve(privatePath);
+    const publicKey = resolve(publicPath);
+    await Promise.all([
+        mkdir(dirname(privateKey), { recursive: true }),
+        mkdir(dirname(publicKey), { recursive: true }),
+    ]);
+    await writeFile(privateKey, privatePem, { mode: 0o600, flag: "wx" });
+    await writeFile(publicKey, publicPem, { mode: 0o644, flag: "wx" });
+    return { privateKey, publicKey, fingerprint: fingerprint(pair.publicKey) };
+}
+export async function signJsonFile(input, privateKeyPath, output) {
+    const payload = JSON.parse(await readFile(resolve(input), "utf8"));
+    const privateKey = await readFile(resolve(privateKeyPath), "utf8");
+    const envelope = signPayload(payload, privateKey);
+    const target = resolve(output);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, `${JSON.stringify(envelope, null, 2)}\n`, {
+        flag: "wx",
+    });
+    return envelope;
+}
+export async function verifyJsonFile(input, publicKeyPath) {
+    const envelope = JSON.parse(await readFile(resolve(input), "utf8"));
+    const publicKey = await readFile(resolve(publicKeyPath), "utf8");
+    return verifyEnvelope(envelope, publicKey);
+}