obsidian-second-brain 0.1.0

package/dist/init.js

@@ -0,0 +1,343 @@
+import { constants as fsConstants } from "node:fs";
+import { access, lstat, mkdir, readFile, realpath } from "node:fs/promises";
+import { join, resolve, sep } from "node:path";
+import { writeFileAtomic } from "./filesystem.js";
+import { emptyInstallManifest, recordInstalledFile, saveInstallManifest } from "./install-manifest.js";
+import { applyManagedSection } from "./managed-section.js";
+import { installLaunchdJob, renderTemplate } from "./plist.js";
+export const HOURLY_LABEL = "com.second-brain.hourly";
+export const WEEKLY_LABEL = "com.second-brain.weekly";
+export async function runInit(options, dependencies) {
+    if (options.force && options.keepExisting) {
+        throw new Error("--force and --keep-existing are mutually exclusive");
+    }
+    const claudeDir = resolve(options.claudeDir);
+    const vaultDir = resolve(options.vaultDir);
+    const warnings = [];
+    await validateClaudeDir(claudeDir);
+    await validateVaultDir(vaultDir, options.newVault, dependencies.home);
+    detectSyncedVault(vaultDir, warnings);
+    const binPath = join(dependencies.appDir, "dist", "cli.js");
+    try {
+        await access(binPath);
+    }
+    catch {
+        throw new Error(`Built bin not found at ${binPath} — run \`npm run build\` first`);
+    }
+    const created = [];
+    const kept = [];
+    const overridden = [];
+    let manifest = emptyInstallManifest();
+    const date = dependencies.now().toISOString().slice(0, 10);
+    const placeFile = async (filePath, content, record) => {
+        const outcome = await placeFileWithPolicy(filePath, content, options, dependencies, date);
+        if (outcome === "created") {
+            created.push(filePath);
+        }
+        else if (outcome === "overridden") {
+            overridden.push(filePath);
+        }
+        else {
+            kept.push(filePath);
+        }
+        // A kept file that already matches the template is ours too — record it
+        // so uninstall can clean it up.
+        if (record && (outcome !== "kept" || (await fileMatches(filePath, content)))) {
+            manifest = recordInstalledFile(manifest, filePath, content);
+        }
+    };
+    // 1. Vault scaffold (retained by uninstall — never recorded in the manifest).
+    await mkdir(join(vaultDir, "raw", "artifacts"), { recursive: true });
+    await mkdir(join(vaultDir, "raw", "projects"), { recursive: true });
+    await mkdir(join(vaultDir, "wiki", "episodes"), { recursive: true });
+    const template = (name) => readFile(join(dependencies.appDir, "templates", name), "utf8");
+    await placeFile(join(vaultDir, "AGENTS.md"), await template("vault-agents.md"), false);
+    // Claude Code loads CLAUDE.md, not AGENTS.md: the include makes a session
+    // opened inside the vault follow the same LLM-wiki spec.
+    await placeFile(join(vaultDir, "CLAUDE.md"), await template("vault-claude-md.md"), false);
+    await placeFile(join(vaultDir, ".gitignore"), await template("vault-gitignore"), false);
+    await placeFile(join(vaultDir, "wiki", "index.md"), await template("wiki-index.md"), false);
+    await placeFile(join(vaultDir, "wiki", "log.md"), await template("wiki-log.md"), false);
+    await createIfAbsent(join(vaultDir, "wiki", ".ingest-state.json"), "{}\n", created);
+    await createIfAbsent(join(vaultDir, "raw", "artifacts", ".gitkeep"), "", created);
+    await createIfAbsent(join(vaultDir, "wiki", "episodes", ".gitkeep"), "", created);
+    await initVaultGit(vaultDir, dependencies, warnings);
+    // 2. Synthesis preflight (design 7.6): the backend must work in a
+    // launchd-equivalent environment, otherwise fall back to noop.
+    const { backend, claudeBin } = await preflightClaude(dependencies, warnings);
+    // 3. Generated config — recorded so uninstall can remove it if unchanged.
+    const configContent = `${JSON.stringify({
+        logsRoot: "../logs",
+        providers: [
+            {
+                destinationPath: "sessions/claude",
+                enabled: true,
+                name: "claude",
+                sourceRoot: join(claudeDir, "projects")
+            }
+        ],
+        synthesis: claudeBin === undefined ? { backend } : { backend, claudeBin },
+        vaultRoot: join(vaultDir, "raw", "projects")
+    }, null, 2)}\n`;
+    await placeFile(join(dependencies.appDir, "config", "projects.json"), configContent, true);
+    // 4. Capture layer: /wrap command + managed CLAUDE.md section.
+    await mkdir(join(claudeDir, "commands"), { recursive: true });
+    const wrapContent = renderTemplate(await template("wrap-command.md"), {
+        VAULT: vaultDir
+    });
+    await placeFile(join(claudeDir, "commands", "wrap.md"), wrapContent, true);
+    await installManagedSection(join(claudeDir, "CLAUDE.md"), renderTemplate(await template("claude-md-section.md"), { VAULT: vaultDir }), date, created, overridden, warnings, dependencies.log);
+    // 5. launchd jobs from templates.
+    const plists = [];
+    if (!options.skipLaunchd) {
+        const variables = {
+            APP_DIR: dependencies.appDir,
+            BIN_PATH: binPath,
+            NODE_PATH: dependencies.nodePath
+        };
+        for (const [label, templateName] of [
+            [HOURLY_LABEL, "launchd.plist.template"],
+            [WEEKLY_LABEL, "launchd-weekly.plist.template"]
+        ]) {
+            const content = renderTemplate(await template(templateName), variables);
+            const plistPath = await installLaunchdJob({
+                exec: dependencies.exec,
+                label,
+                launchAgentsDir: dependencies.launchAgentsDir,
+                plistContent: content,
+                uid: dependencies.uid
+            });
+            manifest = recordInstalledFile(manifest, plistPath, content);
+            plists.push(plistPath);
+        }
+    }
+    await saveInstallManifest(installManifestPath(dependencies.appDir), manifest);
+    for (const warning of warnings) {
+        dependencies.log(`warning: ${warning}`);
+    }
+    return { backend, created, kept, overridden, plists, warnings };
+}
+export function installManifestPath(appDir) {
+    return join(appDir, "config", "install-manifest.json");
+}
+async function validateClaudeDir(claudeDir) {
+    try {
+        await access(join(claudeDir, "projects"));
+    }
+    catch {
+        throw new Error(`Claude folder has no projects/ directory: ${claudeDir} — is this really the Claude folder?`);
+    }
+}
+async function validateVaultDir(vaultDir, newVault, home) {
+    const resolvedHome = resolve(home);
+    if (vaultDir === resolvedHome ||
+        vaultDir === "/" ||
+        resolvedHome.startsWith(`${vaultDir}${sep}`)) {
+        throw new Error(`Refusing suspicious vault root: ${vaultDir}`);
+    }
+    if (newVault) {
+        await mkdir(vaultDir, { recursive: true });
+        return;
+    }
+    try {
+        await access(join(vaultDir, ".obsidian"));
+    }
+    catch {
+        throw new Error(`${vaultDir} has no .obsidian/ — open this folder in Obsidian once and re-run, or pass --new-vault`);
+    }
+}
+function detectSyncedVault(vaultDir, warnings) {
+    if (vaultDir.includes(`${sep}Library${sep}Mobile Documents${sep}`) ||
+        vaultDir.includes(`${sep}Dropbox${sep}`) ||
+        vaultDir.toLowerCase().includes("icloud")) {
+        warnings.push("vault lives in a synced folder (iCloud/Dropbox): concurrent sync engines can produce conflicted copies; the vault git history is the recovery path");
+    }
+}
+async function placeFileWithPolicy(filePath, content, options, dependencies, date) {
+    let existing;
+    try {
+        existing = await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            throw error;
+        }
+    }
+    if (existing === undefined) {
+        await writeFileAtomic(filePath, content);
+        return "created";
+    }
+    if (existing === content) {
+        return "kept";
+    }
+    let override;
+    if (options.force) {
+        override = true;
+    }
+    else if (options.keepExisting) {
+        override = false;
+    }
+    else if (dependencies.isTTY) {
+        override = await dependencies.askYesNo(`${filePath} already exists — override with the template? [y/N]`);
+    }
+    else {
+        throw new Error(`Conflicting file in non-interactive mode: ${filePath} — re-run with --force or --keep-existing`);
+    }
+    if (!override) {
+        return "kept";
+    }
+    await writeBackup(filePath, existing, date);
+    await writeFileAtomic(filePath, content);
+    return "overridden";
+}
+async function writeBackup(filePath, content, date) {
+    // A same-day re-init must never clobber an earlier backup — that file can
+    // be the only copy of what the user had before the first override.
+    for (let suffix = 1; suffix <= 50; suffix += 1) {
+        const candidate = suffix === 1
+            ? `${filePath}.bak-${date}`
+            : `${filePath}.bak-${date}-${suffix}`;
+        try {
+            await lstat(candidate);
+        }
+        catch {
+            await writeFileAtomic(candidate, content);
+            return candidate;
+        }
+    }
+    throw new Error(`Could not claim a free backup path for ${filePath}`);
+}
+async function createIfAbsent(filePath, content, created) {
+    try {
+        await access(filePath);
+    }
+    catch {
+        await writeFileAtomic(filePath, content);
+        created.push(filePath);
+    }
+}
+async function initVaultGit(vaultDir, dependencies, warnings) {
+    try {
+        await dependencies.exec("git", ["rev-parse", "--git-dir"], vaultDir);
+        return;
+    }
+    catch {
+        // Not a repo yet — initialize it below.
+    }
+    try {
+        await dependencies.exec("git", ["init", "-b", "main"], vaultDir);
+        await dependencies.exec("git", ["add", "-A"], vaultDir);
+        await dependencies.exec("git", ["commit", "-m", "chore: vault baseline (second-brain init)"], vaultDir);
+    }
+    catch (error) {
+        warnings.push(`vault git setup incomplete: ${error instanceof Error ? error.message : "unknown error"}`);
+    }
+}
+// launchd starts jobs with this PATH — not the user's shell PATH. The
+// preflight must reproduce it, or it passes interactively and the scheduled
+// runs fail with ENOENT (or hit a wrapper that itself needs the shell PATH).
+const LAUNCHD_PATH = "/usr/bin:/bin:/usr/sbin:/sbin";
+async function preflightClaude(dependencies, warnings) {
+    for (const candidate of await claudeCandidates(dependencies)) {
+        try {
+            await dependencies.exec(candidate, ["--version"], dependencies.home, {
+                ...dependencies.env,
+                PATH: LAUNCHD_PATH
+            });
+            return { backend: "cli-claude", claudeBin: candidate };
+        }
+        catch {
+            // IDE/terminal wrappers named "claude" often just re-exec the real CLI
+            // from the shell PATH — they fail here by design; try the next one.
+        }
+    }
+    warnings.push("claude CLI preflight failed under a launchd-equivalent PATH — synthesis.backend set to noop; set synthesis.claudeBin to your claude binary's absolute path and backend to cli-claude in config/projects.json");
+    return { backend: "noop" };
+}
+async function claudeCandidates(dependencies) {
+    const directories = [
+        ...(dependencies.env.PATH ?? "").split(":").filter((entry) => entry !== ""),
+        // Installer defaults, in case the current shell's PATH misses them.
+        join(dependencies.home, ".local", "bin"),
+        "/opt/homebrew/bin",
+        "/usr/local/bin"
+    ];
+    const candidates = [];
+    for (const directory of directories) {
+        const candidate = join(directory, "claude");
+        if (candidates.includes(candidate)) {
+            continue;
+        }
+        try {
+            await access(candidate, fsConstants.X_OK);
+            candidates.push(candidate);
+        }
+        catch {
+            // Not present or not executable here — keep scanning.
+        }
+    }
+    return candidates;
+}
+async function installManagedSection(claudeMdPath, block, date, created, overridden, warnings, log) {
+    let targetPath = claudeMdPath;
+    let isSymlink = false;
+    try {
+        isSymlink = (await lstat(claudeMdPath)).isSymbolicLink();
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            throw error;
+        }
+    }
+    if (isSymlink) {
+        // CLAUDE.md often symlinks into a dotfiles repo: edit the real file so
+        // the link survives — replacing the symlink would orphan their setup.
+        try {
+            targetPath = await realpath(claudeMdPath);
+        }
+        catch {
+            warnings.push(`${claudeMdPath} is a dangling symlink — managed section not installed; fix the link target and re-run`);
+            return;
+        }
+    }
+    let existing;
+    try {
+        existing = await readFile(targetPath, "utf8");
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            throw error;
+        }
+    }
+    const next = applyManagedSection(existing, block);
+    if (existing === next) {
+        return;
+    }
+    // The section is strictly additive: content outside the markers is never
+    // touched. Still, this is the user's instruction file — back it up, tell
+    // them exactly what happened, and ask them to review.
+    if (existing === undefined) {
+        created.push(targetPath);
+        await writeFileAtomic(targetPath, next);
+        log(`review: created ${targetPath} with the second-brain section — please review it`);
+        return;
+    }
+    const backupPath = await writeBackup(targetPath, existing, date);
+    overridden.push(targetPath);
+    await writeFileAtomic(targetPath, next);
+    log(`review: added/updated the second-brain section in ${targetPath} — your content outside the markers is untouched (backup: ${backupPath}); please review`);
+}
+async function fileMatches(filePath, content) {
+    try {
+        return (await readFile(filePath, "utf8")) === content;
+    }
+    catch {
+        return false;
+    }
+}
+function isMissingFileError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        typeof error.code === "string" &&
+        error.code === "ENOENT");
+}

package/dist/install-manifest.js

@@ -0,0 +1,56 @@
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+import { hashContent } from "./changeset.js";
+import { writeFileAtomic } from "./filesystem.js";
+const installManifestSchema = z.object({
+    files: z.record(z.string(), z.object({ hash: z.string() })).default({}),
+    version: z.literal(1).default(1)
+});
+export function emptyInstallManifest() {
+    return { files: {}, version: 1 };
+}
+export async function loadInstallManifest(manifestPath) {
+    let raw;
+    try {
+        raw = await readFile(manifestPath, "utf8");
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return emptyInstallManifest();
+        }
+        throw error;
+    }
+    const trimmed = raw.trim();
+    const parsed = trimmed.length === 0 ? {} : JSON.parse(trimmed);
+    return installManifestSchema.parse(parsed);
+}
+export async function saveInstallManifest(manifestPath, manifest) {
+    await writeFileAtomic(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+export function recordInstalledFile(manifest, filePath, content) {
+    return {
+        files: { ...manifest.files, [filePath]: { hash: hashContent(content) } },
+        version: manifest.version
+    };
+}
+// True when the file on disk still matches what init wrote — only then may
+// uninstall delete it (design 7.6).
+export async function isUnchangedInstalledFile(manifest, filePath) {
+    const entry = manifest.files[filePath];
+    if (entry === undefined) {
+        return false;
+    }
+    try {
+        const content = await readFile(filePath, "utf8");
+        return hashContent(content) === entry.hash;
+    }
+    catch {
+        return false;
+    }
+}
+function isMissingFileError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        typeof error.code === "string" &&
+        error.code === "ENOENT");
+}

package/dist/lock.js

@@ -0,0 +1,73 @@
+import { readFile, rm, writeFile } from "node:fs/promises";
+const STALE_LOCK_MS = 2 * 60 * 60 * 1000;
+const defaultDependencies = {
+    isProcessAlive: (pid) => {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    now: () => new Date(),
+    pid: process.pid
+};
+export async function acquireLock(lockPath, dependencies = defaultDependencies) {
+    const payload = `${JSON.stringify({
+        acquiredAt: dependencies.now().toISOString(),
+        pid: dependencies.pid
+    })}\n`;
+    try {
+        await writeFile(lockPath, payload, { flag: "wx" });
+    }
+    catch (error) {
+        if (!isExistsError(error)) {
+            throw error;
+        }
+        await takeOverStaleLock(lockPath, dependencies);
+        // If a competitor re-created the lock in this window, the second wx write
+        // intentionally surfaces the lost takeover as a hard failure.
+        await writeFile(lockPath, payload, { flag: "wx" });
+    }
+    return {
+        release: async () => {
+            await rm(lockPath, { force: true });
+        }
+    };
+}
+async function takeOverStaleLock(lockPath, dependencies) {
+    const holder = await readLockHolder(lockPath);
+    const isStale = holder === undefined ||
+        !dependencies.isProcessAlive(holder.pid) ||
+        dependencies.now().getTime() - Date.parse(holder.acquiredAt) > STALE_LOCK_MS;
+    if (!isStale) {
+        throw new Error(`Another instance holds the lock: ${lockPath} (pid ${holder.pid}, since ${holder.acquiredAt})`);
+    }
+    await rm(lockPath, { force: true });
+}
+async function readLockHolder(lockPath) {
+    try {
+        const raw = await readFile(lockPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === "object" &&
+            parsed !== null &&
+            "pid" in parsed &&
+            typeof parsed.pid === "number" &&
+            "acquiredAt" in parsed &&
+            typeof parsed.acquiredAt === "string" &&
+            !Number.isNaN(Date.parse(parsed.acquiredAt))) {
+            return { acquiredAt: parsed.acquiredAt, pid: parsed.pid };
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isExistsError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        typeof error.code === "string" &&
+        error.code === "EEXIST");
+}

package/dist/logger.js

@@ -0,0 +1,19 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+export function createLogger(logsRoot) {
+    const lines = [];
+    return {
+        async flush() {
+            await mkdir(logsRoot, { recursive: true });
+            const timestamp = new Date().toISOString().replaceAll(":", "-");
+            const logPath = join(logsRoot, `${timestamp}.log`);
+            const payload = `${lines.join("\n")}\n`;
+            await appendFile(logPath, payload, "utf8");
+            return logPath;
+        },
+        info(message) {
+            lines.push(`[${new Date().toISOString()}] ${message}`);
+            process.stdout.write(`${message}\n`);
+        }
+    };
+}

package/dist/managed-section.js

@@ -0,0 +1,30 @@
+const BEGIN_MARKER = "<!-- BEGIN second-brain (managed by second-brain init — do not edit inside) -->";
+const END_MARKER = "<!-- END second-brain -->";
+export function hasManagedSection(content) {
+    return content.includes(BEGIN_MARKER) && content.includes(END_MARKER);
+}
+// Idempotent: re-applying replaces the block in place, never duplicates
+// (design 7.3). The block argument must already contain the markers.
+export function applyManagedSection(existing, block) {
+    const trimmedBlock = block.trim();
+    if (existing === undefined || existing.trim().length === 0) {
+        return `${trimmedBlock}\n`;
+    }
+    if (hasManagedSection(existing)) {
+        const beginIndex = existing.indexOf(BEGIN_MARKER);
+        const endIndex = existing.indexOf(END_MARKER) + END_MARKER.length;
+        return `${existing.slice(0, beginIndex)}${trimmedBlock}${existing.slice(endIndex)}`;
+    }
+    return `${existing.replace(/\n+$/u, "")}\n\n${trimmedBlock}\n`;
+}
+export function removeManagedSection(content) {
+    if (!hasManagedSection(content)) {
+        return content;
+    }
+    const beginIndex = content.indexOf(BEGIN_MARKER);
+    const endIndex = content.indexOf(END_MARKER) + END_MARKER.length;
+    const before = content.slice(0, beginIndex).replace(/\n+$/u, "");
+    const after = content.slice(endIndex).replace(/^\n+/u, "");
+    const joined = [before, after].filter((part) => part.length > 0).join("\n");
+    return joined.length > 0 ? `${joined}\n` : "";
+}

package/dist/manifest.js

@@ -0,0 +1,64 @@
+import { access, readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "./filesystem.js";
+const manifestEntrySchema = z.object({
+    contentHash: z.string().regex(/^[0-9a-f]{64}$/u),
+    ingestedAt: z.iso.datetime()
+});
+const manifestSchema = z.object({
+    entries: z.record(z.string(), manifestEntrySchema).default({}),
+    version: z.literal(1).default(1)
+});
+export function buildSourceKey(input) {
+    // Segments are escaped so a ':' inside any field (e.g. a sessionId that fell
+    // back to a filename) cannot collide with the delimiter.
+    return [input.provider, input.type, input.sessionId]
+        .map((segment) => encodeURIComponent(segment))
+        .join(":");
+}
+export function emptyManifest() {
+    return { entries: {}, version: 1 };
+}
+export async function loadManifest(manifestPath) {
+    let raw;
+    try {
+        raw = await readFile(manifestPath, "utf8");
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            // A missing file in an existing wiki/ is a genuinely fresh manifest; a
+            // missing parent directory means the path is misconfigured, and silently
+            // starting empty would re-synthesize the corpus against the wrong vault.
+            await assertParentDirectoryExists(manifestPath);
+            return emptyManifest();
+        }
+        throw error;
+    }
+    const trimmed = raw.trim();
+    const parsed = trimmed.length === 0 ? {} : JSON.parse(trimmed);
+    return manifestSchema.parse(parsed);
+}
+export async function saveManifest(manifestPath, manifest) {
+    await writeFileAtomic(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+export function withManifestEntries(manifest, entries) {
+    return {
+        entries: { ...manifest.entries, ...entries },
+        version: manifest.version
+    };
+}
+async function assertParentDirectoryExists(manifestPath) {
+    try {
+        await access(dirname(manifestPath));
+    }
+    catch {
+        throw new Error(`Manifest directory does not exist: ${dirname(manifestPath)} — check the vault path or run init`);
+    }
+}
+function isMissingFileError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        typeof error.code === "string" &&
+        error.code === "ENOENT");
+}

package/dist/ollama-backend.js

@@ -0,0 +1,49 @@
+import { readFile } from "node:fs/promises";
+import { parseEpisodePatch } from "./episode-patch.js";
+import { assertEpisodesMatchProject, buildEpisodePrompt } from "./episode-prompt.js";
+const DEFAULT_BASE_URL = "http://127.0.0.1:11434";
+const DEFAULT_MODEL = "llama3.1";
+const defaultDependencies = {
+    fetchFn: fetch,
+    readSource: (path) => readFile(path, "utf8")
+};
+export function createOllamaBackend(options = {}, dependencies = defaultDependencies) {
+    const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    const model = options.model ?? DEFAULT_MODEL;
+    return {
+        name: "ollama",
+        synthesize: async (input) => {
+            const prompt = await buildEpisodePrompt(input, dependencies.readSource);
+            const response = await dependencies.fetchFn(`${baseUrl}/api/chat`, {
+                body: JSON.stringify({
+                    format: "json",
+                    messages: [{ content: prompt, role: "user" }],
+                    model,
+                    stream: false
+                }),
+                headers: { "content-type": "application/json" },
+                method: "POST"
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama request failed: ${response.status} ${response.statusText}`);
+            }
+            const payload = await response.json();
+            const text = extractMessageContent(payload);
+            const patch = parseEpisodePatch(text);
+            assertEpisodesMatchProject(patch.episodes, input.project);
+            return { episodes: patch.episodes };
+        }
+    };
+}
+function extractMessageContent(payload) {
+    if (typeof payload === "object" &&
+        payload !== null &&
+        "message" in payload &&
+        typeof payload.message === "object" &&
+        payload.message !== null &&
+        "content" in payload.message &&
+        typeof payload.message.content === "string") {
+        return payload.message.content;
+    }
+    throw new Error("Unexpected Ollama response: missing message content");
+}

package/dist/plist.js

@@ -0,0 +1,23 @@
+import { join } from "node:path";
+import { writeFileAtomic } from "./filesystem.js";
+export function renderTemplate(template, variables) {
+    return template.replace(/\{\{([A-Z_]+)\}\}/gu, (match, key) => {
+        const value = variables[key];
+        if (value === undefined) {
+            throw new Error(`Template variable without a value: ${match}`);
+        }
+        return value;
+    });
+}
+export async function installLaunchdJob(input) {
+    const plistPath = join(input.launchAgentsDir, `${input.label}.plist`);
+    await writeFileAtomic(plistPath, input.plistContent);
+    // bootout is allowed to fail (job not loaded yet); bootstrap is not.
+    await input.exec("launchctl", ["bootout", `gui/${input.uid}/${input.label}`], "/").catch(() => undefined);
+    await input.exec("launchctl", ["bootstrap", `gui/${input.uid}`, plistPath], "/");
+    return plistPath;
+}
+export async function removeLaunchdJob(input) {
+    await input.exec("launchctl", ["bootout", `gui/${input.uid}/${input.label}`], "/").catch(() => undefined);
+    await input.removeFile(join(input.launchAgentsDir, `${input.label}.plist`));
+}