@minionry/minion 0.7.36

package/dist/server/services/schedule/run-bootstrap.js

@@ -0,0 +1,329 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { extractBoardArchive } from '../plan/board-archive.js';
+import { replaceFrontMatterField } from '../plan/front-matter.js';
+import { getNextBoardId, NO_SPECS_DIR_ERROR, parseBoardDirectory, parsePlanDirectory, resolvePmDir } from '../plan/parser.js';
+import { parseFrontMatter, parseIssue } from '../plan/parser-core.js';
+import { reconcileState } from '../plan/state-reconciler.js';
+import { instantiateTemplate, loadTemplate, substitute } from '../plan/template-instantiator.js';
+import { registerBoardInWorkspace, writeExtractedBoard } from '../websocket/plan-transfer-handlers.js';
+export const RUN_INPUT_PATH = 'out/run-input.json';
+export const RUN_INPUT_SCHEMA = 'minionry-board-run-input/1';
+export const GATHER_ISSUE_ID = 'IS-000';
+export const GATHER_ISSUE_TITLE = 'Gather dependency data';
+export class RunBootstrapError extends Error {
+    code;
+    variables;
+    constructor(code, message, 
+    variables) {
+        super(message);
+        this.code = code;
+        this.variables = variables;
+        this.name = 'RunBootstrapError';
+    }
+}
+export function coerceVariables(variables) {
+    const coerced = {};
+    for (const [name, value] of Object.entries(variables ?? {})) {
+        coerced[name] = String(value);
+    }
+    return coerced;
+}
+function assertRequiredVariables(template, supplied) {
+    const missing = (template.variables ?? [])
+        .filter(v => v.required && supplied[v.name] === undefined && v.default === undefined)
+        .map(v => v.name);
+    if (missing.length > 0) {
+        throw new RunBootstrapError('missing_variables', `Missing required template variable(s): ${missing.join(', ')}`, missing);
+    }
+}
+const PRIOR_RUN_DIR_PREFIXES = ['out/', 'reviews/', 'logs/'];
+const PRIOR_RUN_FILES = new Set(['progress.md']);
+function isPriorRunArtifact(relPath) {
+    return PRIOR_RUN_DIR_PREFIXES.some(prefix => relPath.startsWith(prefix)) || PRIOR_RUN_FILES.has(relPath);
+}
+function isBacklogIssue(relPath) {
+    return relPath.startsWith('backlog/') && relPath.endsWith('.md');
+}
+function clearSection(content, heading) {
+    const start = content.indexOf(`## ${heading}`);
+    if (start === -1)
+        return content;
+    const afterHeading = content.indexOf('\n', start);
+    if (afterHeading === -1)
+        return content;
+    const nextSection = content.slice(afterHeading).search(/\n## /);
+    const end = nextSection === -1 ? content.length : afterHeading + nextSection;
+    return `${content.slice(0, afterHeading)}\n${content.slice(end)}`;
+}
+function uncheckAcceptanceCriteria(content) {
+    const sectionStart = content.indexOf('## Acceptance Criteria');
+    if (sectionStart === -1)
+        return content;
+    const afterHeader = content.indexOf('\n', sectionStart);
+    if (afterHeader === -1)
+        return content;
+    const nextSection = content.slice(afterHeader).search(/\n## /);
+    const sectionEnd = nextSection !== -1 ? afterHeader + nextSection : content.length;
+    const section = content.slice(afterHeader, sectionEnd).replace(/^([-*]\s+)\[[xX]\]/gm, '$1[ ]');
+    return content.slice(0, afterHeader) + section + content.slice(sectionEnd);
+}
+function blankIssueMarkdown(content) {
+    let blanked = replaceFrontMatterField(content, 'status', 'todo');
+    blanked = uncheckAcceptanceCriteria(blanked);
+    blanked = clearSection(blanked, 'Activity');
+    blanked = clearSection(blanked, 'Output History');
+    return blanked;
+}
+function blankBoardMarkdown(content) {
+    const blanked = replaceFrontMatterField(content, 'status', 'draft');
+    return replaceFrontMatterField(blanked, 'completed_at', 'null');
+}
+function prepareZipFiles(files, variables) {
+    const prepared = new Map();
+    for (const [relPath, bytes] of files) {
+        if (isPriorRunArtifact(relPath))
+            continue;
+        if (relPath !== 'board.md' && !isBacklogIssue(relPath)) {
+            prepared.set(relPath, bytes);
+            continue;
+        }
+        const text = substitute(Buffer.from(bytes).toString('utf-8'), variables);
+        const blanked = relPath === 'board.md' ? blankBoardMarkdown(text) : blankIssueMarkdown(text);
+        prepared.set(relPath, Buffer.from(blanked, 'utf-8'));
+    }
+    return prepared;
+}
+function ensureStateFile(boardDir) {
+    const statePath = join(boardDir, 'STATE.md');
+    if (existsSync(statePath))
+        return;
+    const skeleton = [
+        '---',
+        'project: ../../project.md',
+        'board: board.md',
+        'paused: false',
+        '---',
+        '',
+        '# Board State',
+        '',
+        '## Ready to Work',
+        '',
+        '## In Progress',
+        '',
+        '## Blocked',
+        '',
+        '## Recently Completed',
+        '',
+        '## Warnings',
+        '',
+    ].join('\n');
+    writeFileSync(statePath, skeleton, 'utf-8');
+}
+export function writeRunInputFile(boardDir, options) {
+    const file = {
+        schema: RUN_INPUT_SCHEMA,
+        runAt: options.runAt ?? new Date().toISOString(),
+        boardId: options.boardId,
+        ...(options.scheduleId ? { scheduleId: options.scheduleId } : {}),
+        data: options.data,
+    };
+    const outDir = join(boardDir, 'out');
+    mkdirSync(outDir, { recursive: true });
+    const path = join(outDir, 'run-input.json');
+    writeFileSync(path, JSON.stringify(file, null, 2), 'utf-8');
+    return path;
+}
+function readBacklogFiles(boardDir) {
+    const backlogDir = join(boardDir, 'backlog');
+    if (!existsSync(backlogDir))
+        return [];
+    return readdirSync(backlogDir)
+        .filter(name => name.endsWith('.md'))
+        .sort()
+        .map(name => ({
+        relPath: `backlog/${name}`,
+        absPath: join(backlogDir, name),
+        content: readFileSync(join(backlogDir, name), 'utf-8'),
+    }));
+}
+function setFrontMatterList(content, field, values) {
+    const fmMatch = content.match(/^(---\n)([\s\S]*?)(\n---)/);
+    if (!fmMatch)
+        return content;
+    const rendered = `${field}: [${values.map(v => `"${v.replace(/"/g, '\\"')}"`).join(', ')}]`;
+    const lines = fmMatch[2].split('\n');
+    const index = lines.findIndex(line => line.startsWith(`${field}:`));
+    if (index === -1) {
+        lines.push(rendered);
+    }
+    else {
+        let end = index + 1;
+        while (end < lines.length && /^\s+-\s/.test(lines[end]))
+            end++;
+        lines.splice(index, end - index, rendered);
+    }
+    return `${fmMatch[1]}${lines.join('\n')}${fmMatch[3]}${content.slice(fmMatch[0].length)}`;
+}
+function resolveGatherIssueId(backlog) {
+    const taken = new Set(backlog.map(f => f.relPath));
+    if (!taken.has(`backlog/${GATHER_ISSUE_ID}.md`))
+        return GATHER_ISSUE_ID;
+    for (let n = 2;; n++) {
+        const candidate = `${GATHER_ISSUE_ID}-${n}`;
+        if (!taken.has(`backlog/${candidate}.md`))
+            return candidate;
+    }
+}
+function renderGatherIssue(options) {
+    const { issueId, gatherPrompt, rootPaths, created, hasRunInput } = options;
+    const frontMatter = [
+        '---',
+        `id: ${issueId}`,
+        `title: "${GATHER_ISSUE_TITLE}"`,
+        'type: issue',
+        'status: todo',
+        'priority: P0',
+        'estimate: 1',
+        'labels: ["gather", "auto-generated"]',
+        `created: "${created}"`,
+        'blocked_by: []',
+        `blocks: [${rootPaths.map(p => `"${p}"`).join(', ')}]`,
+        'review_gate: none',
+        'output_type: document',
+        `output_file: "out/${issueId}-gathered-data.md"`,
+        '---',
+    ].join('\n');
+    const body = [
+        '',
+        `# ${issueId}: ${GATHER_ISSUE_TITLE}`,
+        '',
+        '## Description',
+        '',
+        'This board run was started with a data-gathering step. Complete it before any',
+        'implementation issue begins — every root issue on this board is blocked by it.',
+        '',
+        '**Gather instruction (from the run input):**',
+        '',
+        gatherPrompt,
+        '',
+        '## Acceptance Criteria',
+        '',
+        '- [ ] The requested data has been gathered (run the script, search the web, or',
+        '      read the changed files on disk — whatever the instruction above calls for)',
+        `- [ ] Findings are written to \`out/${issueId}-gathered-data.md\``,
+        '- [ ] Every backlog issue whose description depends on this data has been',
+        '      updated in place under `backlog/` with the concrete, current values',
+        '- [ ] Issues that are now unnecessary are set to `status: cancelled` with a',
+        '      one-line reason; issues that are now needed have been added',
+        '',
+        '## Technical Notes',
+        '',
+        'You may edit files under `backlog/` — that is the point of this issue. Do not',
+        'edit `STATE.md` (the orchestrator owns it) and do not start implementing the',
+        'downstream issues yourself.',
+        ...(hasRunInput ? ['', `The run's data payload is at \`${RUN_INPUT_PATH}\`.`] : []),
+        '',
+    ].join('\n');
+    return `${frontMatter}\n${body}`;
+}
+export function injectGatherIssue(boardDir, gatherPrompt, options) {
+    const backlog = readBacklogFiles(boardDir);
+    const roots = backlog.filter(file => {
+        const issue = parseIssue(file.content, file.relPath);
+        return issue.type !== 'epic' && issue.blockedBy.length === 0;
+    });
+    if (roots.length === 0) {
+        throw new RunBootstrapError('no_root_issues', 'no root issues to block');
+    }
+    const issueId = resolveGatherIssueId(backlog);
+    const gatherPath = `backlog/${issueId}.md`;
+    const rootPaths = roots.map(file => file.relPath);
+    const markdown = renderGatherIssue({
+        issueId,
+        gatherPrompt,
+        rootPaths,
+        created: options?.created ?? new Date().toISOString().split('T')[0],
+        hasRunInput: options?.hasRunInput ?? false,
+    });
+    writeFileSync(join(boardDir, gatherPath), markdown, 'utf-8');
+    for (const root of roots) {
+        const { frontMatter } = parseFrontMatter(root.content);
+        const existing = Array.isArray(frontMatter.blocked_by) ? frontMatter.blocked_by.map(String) : [];
+        const updated = setFrontMatterList(root.content, 'blocked_by', [...existing, gatherPath]);
+        writeFileSync(root.absPath, updated, 'utf-8');
+    }
+    return { issueId, path: gatherPath, rootPaths };
+}
+function materializeFromTemplate(source, pmDir, boardId, variables) {
+    let template;
+    try {
+        template = loadTemplate(source.durablePath);
+    }
+    catch (error) {
+        throw new RunBootstrapError('invalid_source', error instanceof Error ? error.message : String(error));
+    }
+    assertRequiredVariables(template, variables);
+    instantiateTemplate(template, { pmDir, boardId, variables });
+}
+function materializeFromZip(source, boardId, boardDir, existingTitles, variables) {
+    let extracted;
+    try {
+        extracted = extractBoardArchive(readFileSync(source.durablePath));
+    }
+    catch (error) {
+        throw new RunBootstrapError('invalid_source', error instanceof Error ? error.message : String(error));
+    }
+    writeExtractedBoard({
+        files: prepareZipFiles(extracted.files, variables),
+        sourceBoardId: extracted.sourceBoardId,
+        newBoardId: boardId,
+        boardDir,
+        existingTitles,
+    });
+    ensureStateFile(boardDir);
+}
+export function bootstrapRun(workingDir, source, input, options) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir) {
+        throw new RunBootstrapError('no_pm_dir', NO_SPECS_DIR_ERROR);
+    }
+    const fullState = parsePlanDirectory(workingDir);
+    if (!fullState) {
+        throw new RunBootstrapError('no_pm_dir', 'Failed to parse PM directory');
+    }
+    const boardId = getNextBoardId(fullState.boards);
+    const boardDir = join(pmDir, 'boards', boardId);
+    const variables = coerceVariables(input?.variables);
+    let board;
+    try {
+        if (source.kind === 'template-json') {
+            materializeFromTemplate(source, pmDir, boardId, variables);
+        }
+        else {
+            materializeFromZip(source, boardId, boardDir, fullState.boards.map(b => b.title), variables);
+        }
+        if (input?.data !== undefined) {
+            writeRunInputFile(boardDir, { boardId, data: input.data, scheduleId: options?.scheduleId });
+        }
+        if (input?.gatherPrompt) {
+            injectGatherIssue(boardDir, input.gatherPrompt, { hasRunInput: input.data !== undefined });
+        }
+        reconcileState(workingDir, boardId);
+        const boardState = parseBoardDirectory(pmDir, boardId);
+        if (!boardState) {
+            throw new RunBootstrapError('parse_failed', `Bootstrapped board failed to parse: ${boardId}`);
+        }
+        board = boardState.board;
+    }
+    catch (error) {
+        rmSync(boardDir, { recursive: true, force: true });
+        throw error;
+    }
+    const workspace = registerBoardInWorkspace(pmDir, boardId);
+    options?.broadcast?.({ type: 'planBoardCreated', data: board });
+    options?.broadcast?.({ type: 'planWorkspaceUpdated', data: workspace });
+    return { boardId, boardDir, board, workspace };
+}

package/dist/server/services/schedule/schedule-store.js

@@ -0,0 +1,238 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { defaultPmDir } from '../plan/parser.js';
+export const SCHEDULE_MIN_INTERVAL_MS = 60_000;
+export const MAX_SCHEDULE_HISTORY = 20;
+function generateScheduleId() {
+    return `sched-${randomUUID().replace(/-/g, '').slice(0, 8)}`;
+}
+function clampTiming(timing) {
+    if (timing.kind === 'interval') {
+        return { kind: 'interval', everyMs: Math.max(timing.everyMs, SCHEDULE_MIN_INTERVAL_MS) };
+    }
+    return timing;
+}
+export function computeNextFireAt(timing, from) {
+    if (timing.kind === 'once') {
+        const at = new Date(timing.at);
+        if (Number.isNaN(at.getTime()))
+            return null;
+        return at.getTime() >= from.getTime() ? at.toISOString() : null;
+    }
+    if (timing.kind === 'interval') {
+        const everyMs = Math.max(timing.everyMs, SCHEDULE_MIN_INTERVAL_MS);
+        return new Date(from.getTime() + everyMs).toISOString();
+    }
+    return null;
+}
+function isScheduleFireStatus(value) {
+    return value === 'started' || value === 'completed' || value === 'failed' || value === 'skipped-overlap' || value === 'missed';
+}
+function normalizeSource(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const s = raw;
+    if (s.kind !== 'template-json' && s.kind !== 'board-zip')
+        return null;
+    if (typeof s.path !== 'string' || !s.path)
+        return null;
+    const source = { kind: s.kind, path: s.path };
+    if (typeof s.originalName === 'string')
+        source.originalName = s.originalName;
+    return source;
+}
+function normalizeTiming(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const t = raw;
+    if (t.kind === 'once') {
+        if (typeof t.at !== 'string' || Number.isNaN(new Date(t.at).getTime()))
+            return null;
+        return { kind: 'once', at: t.at };
+    }
+    if (t.kind === 'interval') {
+        if (typeof t.everyMs !== 'number' || !Number.isFinite(t.everyMs))
+            return null;
+        return clampTiming({ kind: 'interval', everyMs: t.everyMs });
+    }
+    if (t.kind === 'continuous') {
+        return { kind: 'continuous' };
+    }
+    return null;
+}
+function normalizeInput(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    return raw;
+}
+function normalizeHistoryEntry(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const e = raw;
+    if (typeof e.at !== 'string')
+        return null;
+    if (!isScheduleFireStatus(e.status))
+        return null;
+    if (typeof e.boardId !== 'string' && e.boardId !== null)
+        return null;
+    const entry = { at: e.at, status: e.status, boardId: e.boardId };
+    if (typeof e.error === 'string')
+        entry.error = e.error;
+    return entry;
+}
+function normalizeLastFire(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const l = raw;
+    if (typeof l.at !== 'string')
+        return undefined;
+    if (!isScheduleFireStatus(l.status))
+        return undefined;
+    if (typeof l.boardId !== 'string' && l.boardId !== null)
+        return undefined;
+    return { at: l.at, status: l.status, boardId: l.boardId };
+}
+function normalizeScheduleRecord(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const r = raw;
+    if (typeof r.id !== 'string' || !r.id)
+        return null;
+    const source = normalizeSource(r.source);
+    const timing = normalizeTiming(r.timing);
+    if (!source || !timing)
+        return null;
+    const history = Array.isArray(r.history)
+        ? (r.history.map(normalizeHistoryEntry).filter((e) => e !== null))
+        : [];
+    return {
+        ...r,
+        id: r.id,
+        createdAt: typeof r.createdAt === 'string' ? r.createdAt : new Date().toISOString(),
+        name: typeof r.name === 'string' ? r.name : undefined,
+        source,
+        input: normalizeInput(r.input),
+        timing,
+        enabled: typeof r.enabled === 'boolean' ? r.enabled : true,
+        nextFireAt: typeof r.nextFireAt === 'string' ? r.nextFireAt : null,
+        lastFire: normalizeLastFire(r.lastFire),
+        history,
+        consecutiveEmptyRuns: typeof r.consecutiveEmptyRuns === 'number' ? r.consecutiveEmptyRuns : 0,
+    };
+}
+export class ScheduleStore {
+    workingDir;
+    data;
+    constructor(workingDir) {
+        this.workingDir = workingDir;
+        const pmDir = defaultPmDir(workingDir);
+        if (!existsSync(pmDir)) {
+            mkdirSync(pmDir, { recursive: true });
+        }
+        this.data = this.load();
+    }
+    get schedulesPath() {
+        return join(defaultPmDir(this.workingDir), 'schedules.json');
+    }
+    load() {
+        try {
+            if (existsSync(this.schedulesPath)) {
+                const raw = JSON.parse(readFileSync(this.schedulesPath, 'utf-8'));
+                const rawSchedules = Array.isArray(raw?.schedules) ? raw.schedules : [];
+                const schedules = rawSchedules
+                    .map((s) => normalizeScheduleRecord(s))
+                    .filter((s) => s !== null);
+                return { version: 1, schedules };
+            }
+        }
+        catch (error) {
+            console.error('[ScheduleStore] Error loading schedules:', error);
+        }
+        return { version: 1, schedules: [] };
+    }
+    save() {
+        try {
+            writeFileSync(this.schedulesPath, JSON.stringify(this.data, null, 2));
+        }
+        catch (error) {
+            console.error('[ScheduleStore] Error saving schedules:', error);
+        }
+    }
+    list() {
+        return this.data.schedules.map((s) => ({ ...s }));
+    }
+    get(id) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        return record ? { ...record } : undefined;
+    }
+    create(fields) {
+        const now = new Date();
+        const timing = clampTiming(fields.timing);
+        const record = {
+            id: generateScheduleId(),
+            createdAt: now.toISOString(),
+            name: fields.name,
+            source: fields.source,
+            input: fields.input,
+            timing,
+            enabled: fields.enabled ?? true,
+            nextFireAt: computeNextFireAt(timing, now),
+            history: [],
+            consecutiveEmptyRuns: 0,
+        };
+        this.data.schedules.push(record);
+        this.save();
+        return { ...record };
+    }
+    update(id, patch) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        if (patch.name !== undefined)
+            record.name = patch.name;
+        if (patch.input !== undefined)
+            record.input = patch.input === null ? undefined : patch.input;
+        if (patch.enabled !== undefined)
+            record.enabled = patch.enabled;
+        if (patch.timing !== undefined) {
+            record.timing = clampTiming(patch.timing);
+            record.nextFireAt = computeNextFireAt(record.timing, new Date());
+        }
+        this.save();
+        return { ...record };
+    }
+    delete(id) {
+        const index = this.data.schedules.findIndex((s) => s.id === id);
+        if (index === -1)
+            return false;
+        this.data.schedules.splice(index, 1);
+        this.save();
+        return true;
+    }
+    setEnabled(id, enabled) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        record.enabled = enabled;
+        this.save();
+        return { ...record };
+    }
+    recordFire(id, lastFire, nextFireAt, consecutiveEmptyRuns) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        if (consecutiveEmptyRuns !== undefined)
+            record.consecutiveEmptyRuns = consecutiveEmptyRuns;
+        record.history.push(lastFire);
+        if (record.history.length > MAX_SCHEDULE_HISTORY) {
+            record.history.splice(0, record.history.length - MAX_SCHEDULE_HISTORY);
+        }
+        record.lastFire = { at: lastFire.at, boardId: lastFire.boardId, status: lastFire.status };
+        record.nextFireAt = nextFireAt;
+        this.save();
+        return { ...record };
+    }
+}

package/dist/server/services/schedule/schedule-wire.js

@@ -0,0 +1,77 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, relative } from 'node:path';
+import { resolveTemplateSource, TemplateSourceError } from './template-source.js';
+export function parseCreateSourceWire(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const s = raw;
+    if (s.kind !== 'board-zip' && s.kind !== 'template-json')
+        return null;
+    if (typeof s.path === 'string' && s.path)
+        return { kind: s.kind, path: s.path };
+    if (s.kind === 'template-json' && typeof s.content === 'string')
+        return { kind: s.kind, content: s.content };
+    return null;
+}
+export function isValidTiming(t) {
+    if (!t || typeof t !== 'object')
+        return false;
+    const timing = t;
+    if (timing.kind === 'once')
+        return typeof timing.at === 'string' && !Number.isNaN(Date.parse(timing.at));
+    if (timing.kind === 'interval')
+        return typeof timing.everyMs === 'number' && Number.isFinite(timing.everyMs);
+    return timing.kind === 'continuous';
+}
+export function resolveCreateSource(raw, workingDir, pmDir) {
+    const retentionKey = randomUUID();
+    const retentionDir = join(pmDir, 'schedules', retentionKey);
+    let sourcePath = raw.path;
+    if (raw.kind === 'template-json' && raw.content !== undefined) {
+        mkdirSync(retentionDir, { recursive: true });
+        sourcePath = join(retentionDir, 'template.json');
+        writeFileSync(sourcePath, raw.content, 'utf-8');
+    }
+    if (!sourcePath) {
+        throw new TemplateSourceError('invalid_path', 'source.path or source.content is required');
+    }
+    try {
+        const descriptor = resolveTemplateSource({
+            workingDir,
+            pmDir,
+            scheduleId: retentionKey,
+            source: { kind: raw.kind, path: sourcePath },
+        });
+        const source = { kind: descriptor.kind, path: relative(pmDir, descriptor.durablePath) };
+        if (raw.path)
+            source.originalName = basename(raw.path);
+        return { source, descriptor };
+    }
+    catch (error) {
+        rmSync(retentionDir, { recursive: true, force: true });
+        throw error;
+    }
+}
+export function cleanupScheduleSource(pmDir, record) {
+    rmSync(join(pmDir, dirname(record.source.path)), { recursive: true, force: true });
+}
+export function parseUpdatePatch(patch) {
+    const safePatch = {};
+    if (!patch)
+        return safePatch;
+    if ('name' in patch)
+        safePatch.name = patch.name;
+    if ('enabled' in patch)
+        safePatch.enabled = patch.enabled;
+    if ('input' in patch)
+        safePatch.input = patch.input;
+    if ('timing' in patch) {
+        if (!isValidTiming(patch.timing))
+            return null;
+        safePatch.timing = patch.timing;
+    }
+    return safePatch;
+}