@swimmingliu/autovpn 1.4.0

package/dist/jobs/commands.js

@@ -0,0 +1,159 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn as defaultSpawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { publicJobPayload } from './read.js';
+import { createJobStore } from './store.js';
+import { processMatchesJob as defaultProcessMatchesJob, terminateProcessGroup } from './process.js';
+async function defaultResolvePythonCli(env) {
+    // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.
+    const runner = await import('../../lib/runner.mjs');
+    return runner.resolveOrInstallPythonCli({ env });
+}
+function defaultResolveNodeCli() {
+    const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+    return { command: process.execPath, args: [path.join(packageRoot, 'bin', 'autovpn.mjs')] };
+}
+function wantsNodeWorker(env) {
+    return String(env.AUTOVPN_BACKEND ?? '').trim().toLowerCase() !== 'python';
+}
+async function resolveDetachedWorker(env, options) {
+    if (wantsNodeWorker(env)) {
+        return defaultResolveNodeCli();
+    }
+    return options.resolvePythonCli ? await options.resolvePythonCli() : await defaultResolvePythonCli(env);
+}
+function pushFlag(argv, enabled, flag) {
+    if (enabled)
+        argv.push(flag);
+}
+function spawnDetached(command, args, job, options) {
+    const stdoutFd = fs.openSync(String(job.stdout_log), 'a');
+    const stderrFd = fs.openSync(String(job.stderr_log), 'a');
+    try {
+        const child = (options.spawn ?? defaultSpawn)(command, args, {
+            cwd: options.cwd ?? job.project_root,
+            env: options.env ?? process.env,
+            detached: process.platform !== 'win32',
+            stdio: ['ignore', stdoutFd, stderrFd]
+        });
+        child.unref?.();
+        return child;
+    }
+    finally {
+        fs.closeSync(stdoutFd);
+        fs.closeSync(stderrFd);
+    }
+}
+export async function startDetachedRun(command, options = {}) {
+    const outputFormat = command.outputFormat ?? 'jsonl';
+    const jobStore = createJobStore(command.projectRoot, options);
+    const runArgs = ['run', '--project-root', command.projectRoot, '--output', outputFormat];
+    const resolved = await resolveDetachedWorker(options.env ?? process.env, options);
+    const job = jobStore.createRunningJob({
+        kind: 'run',
+        command: [],
+        pid: 0,
+        options: {
+            source_job_id: command.sourceJobId ?? '',
+            resume_latest: Boolean(command.resumeLatest),
+            skip_deploy: Boolean(command.skipDeploy),
+            skip_verify: Boolean(command.skipVerify),
+            output_format: outputFormat
+        }
+    });
+    runArgs.push('--event-log', String(job.event_log), '--human-log', String(job.human_log));
+    pushFlag(runArgs, command.resumeLatest, '--resume-latest');
+    pushFlag(runArgs, command.skipDeploy, '--skip-deploy');
+    pushFlag(runArgs, command.skipVerify, '--skip-verify');
+    job.command = [resolved.command, ...resolved.args, ...runArgs];
+    const child = spawnDetached(resolved.command, [...resolved.args, ...runArgs], job, options);
+    job.pid = Number(child.pid ?? 0);
+    job.pgid = Number(child.pid ?? 0);
+    return jobStore.writeJob(job);
+}
+export async function startDetachedResume(command, options = {}) {
+    const outputFormat = command.outputFormat ?? 'jsonl';
+    const jobStore = createJobStore(command.projectRoot, options);
+    const resolved = await resolveDetachedWorker(options.env ?? process.env, options);
+    const job = jobStore.createRunningJob({
+        kind: 'resume',
+        command: [],
+        pid: 0,
+        options: { source_job_id: command.sourceJobId, session_dir: command.sessionDir, output_format: outputFormat },
+        resumeFrom: command.sessionDir
+    });
+    const pythonArgs = [
+        'resume',
+        'pipeline',
+        '--project-root',
+        command.projectRoot,
+        '--session',
+        command.sessionDir,
+        '--output',
+        outputFormat,
+        '--event-log',
+        String(job.event_log),
+        '--human-log',
+        String(job.human_log)
+    ];
+    job.command = [resolved.command, ...resolved.args, ...pythonArgs];
+    const child = spawnDetached(resolved.command, [...resolved.args, ...pythonArgs], job, options);
+    job.pid = Number(child.pid ?? 0);
+    job.pgid = Number(child.pid ?? 0);
+    return jobStore.writeJob(job);
+}
+export async function startDetachedRetry(command, options = {}) {
+    const outputFormat = command.outputFormat ?? 'jsonl';
+    const jobStore = createJobStore(command.projectRoot, options);
+    const resolved = await resolveDetachedWorker(options.env ?? process.env, options);
+    const retry = { source_artifact_dir: command.artifactDir, stage: command.stage };
+    const job = jobStore.createRunningJob({
+        kind: 'retry',
+        command: [],
+        pid: 0,
+        options: { artifact_dir: command.artifactDir, stage: command.stage, output_format: outputFormat },
+        retry
+    });
+    const pythonArgs = [
+        'retry-stage',
+        '--project-root',
+        command.projectRoot,
+        '--artifact-dir',
+        command.artifactDir,
+        '--stage',
+        command.stage,
+        '--output',
+        outputFormat,
+        '--event-log',
+        String(job.event_log),
+        '--human-log',
+        String(job.human_log)
+    ];
+    job.command = [resolved.command, ...resolved.args, ...pythonArgs];
+    const child = spawnDetached(resolved.command, [...resolved.args, ...pythonArgs], job, options);
+    job.pid = Number(child.pid ?? 0);
+    job.pgid = Number(child.pid ?? 0);
+    return jobStore.writeJob(job);
+}
+export async function stopManagedJob(projectRoot, jobId, options = {}) {
+    const store = createJobStore(projectRoot, options);
+    const job = store.loadJob(jobId);
+    job.status = 'stopping';
+    job.stop_requested_at = options.now?.() ?? new Date().toISOString().replace(/\.\d{3}Z$/, '+00:00');
+    store.writeJob(job);
+    const pid = Number(job.pgid || job.pid || 0);
+    const matcher = options.processMatchesJob ?? defaultProcessMatchesJob;
+    if (pid > 0 && !matcher(pid, Array.isArray(job.command) ? job.command.map(String) : [])) {
+        throw new Error(`refusing to stop pid ${pid}: command does not match AutoVPN job`);
+    }
+    await terminateProcessGroup(pid, options);
+    job.status = 'stopped';
+    job.finished_at = options.now?.() ?? new Date().toISOString().replace(/\.\d{3}Z$/, '+00:00');
+    job.exit_code = 1;
+    job.signal = 'SIGTERM';
+    return store.writeJob(job);
+}
+export function publicStartedPayload(job) {
+    return { ok: true, ...publicJobPayload(job) };
+}

package/dist/jobs/logs.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import { loadJob, tailLog } from './read.js';
+import { readOptionValue } from '../runtime/paths.js';
+function logPathFor(job, argv) {
+    return String((readOptionValue(argv, '--format') === 'jsonl' ? job.event_log : job.human_log) ?? '');
+}
+function readFromOffset(filePath, offset) {
+    if (!fs.existsSync(filePath)) {
+        return { chunk: '', offset };
+    }
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const stat = fs.fstatSync(fd);
+        if (stat.size <= offset) {
+            return { chunk: '', offset: stat.size };
+        }
+        const buffer = Buffer.alloc(stat.size - offset);
+        fs.readSync(fd, buffer, 0, buffer.length, offset);
+        return { chunk: buffer.toString('utf8'), offset: stat.size };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function* followLog(projectRoot, jobId, argv, options = {}) {
+    const env = options.env ?? process.env;
+    const sleep = options.sleep ?? defaultSleep;
+    const pollMs = options.pollMs ?? 1000;
+    const initial = tailLog(projectRoot, jobId, argv, env);
+    if (initial) {
+        yield initial;
+    }
+    let job = loadJob(projectRoot, jobId, env);
+    const filePath = logPathFor(job, argv);
+    let offset = fs.existsSync(filePath) ? Buffer.byteLength(fs.readFileSync(filePath, 'utf8')) : 0;
+    while (['running', 'stopping'].includes(String(job.status ?? ''))) {
+        await sleep(pollMs);
+        const update = readFromOffset(filePath, offset);
+        if (update.chunk) {
+            yield update.chunk;
+        }
+        offset = update.offset;
+        job = loadJob(projectRoot, jobId, env);
+    }
+}

package/dist/jobs/process.js

@@ -0,0 +1,75 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync as defaultSpawnSync } from 'node:child_process';
+export function processMatchesJob(pid, command) {
+    const cmdlinePath = path.join('/proc', String(pid), 'cmdline');
+    if (!fs.existsSync(cmdlinePath)) {
+        return true;
+    }
+    try {
+        const cmdline = fs.readFileSync(cmdlinePath).toString('utf8').replaceAll('\0', ' ');
+        const markers = ['vpn_automation.backend'];
+        if (command.length > 0) {
+            markers.push(path.basename(String(command[0])));
+        }
+        return markers.some((marker) => marker.length > 0 && cmdline.includes(marker));
+    }
+    catch {
+        return false;
+    }
+}
+function defaultIsAlive(pid) {
+    if (pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+function defaultSignalProcess(target, signal, options) {
+    if ((options.platform ?? process.platform) === 'win32') {
+        const tree = signal === 'SIGKILL' ? ['/pid', String(target), '/t', '/f'] : ['/pid', String(target), '/t'];
+        (options.spawnSync ?? defaultSpawnSync)('taskkill', tree, { stdio: 'ignore' });
+        return;
+    }
+    process.kill(target, signal);
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function signalTarget(pid, platform = process.platform) {
+    return platform === 'win32' ? pid : -pid;
+}
+export async function terminateProcessGroup(pid, options = {}) {
+    if (pid <= 0)
+        return;
+    const platform = options.platform ?? process.platform;
+    const isAlive = options.isAlive ?? defaultIsAlive;
+    const signalProcess = options.signalProcess;
+    const sleep = options.sleep ?? defaultSleep;
+    const timeoutMs = options.timeoutMs ?? 4000;
+    const target = signalTarget(pid, platform);
+    if (!isAlive(pid))
+        return;
+    if (signalProcess) {
+        signalProcess(target, 'SIGTERM');
+    }
+    else {
+        defaultSignalProcess(target, 'SIGTERM', options);
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline && isAlive(pid)) {
+        await sleep(100);
+    }
+    if (isAlive(pid)) {
+        if (signalProcess) {
+            signalProcess(target, 'SIGKILL');
+        }
+        else {
+            defaultSignalProcess(target, 'SIGKILL', options);
+        }
+    }
+}

package/dist/jobs/read.js

@@ -0,0 +1,282 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { resolveProfilePath, readOptionValue } from '../runtime/paths.js';
+import { redactText } from '../runtime/redaction.js';
+function jobsRoot(projectRoot, env = process.env) {
+    return path.join(path.dirname(resolveProfilePath(projectRoot, env)), 'jobs');
+}
+function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+function nowIso() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, '+00:00');
+}
+function processAlive(pid) {
+    if (pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+function lastJsonEvents(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    return fs.readFileSync(filePath, 'utf8').split(/\r?\n/).flatMap((line) => {
+        if (!line.trim()) {
+            return [];
+        }
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function reconcileFromPipelineReport(job) {
+    const artifactDir = String(job.artifact_dir ?? '');
+    if (!artifactDir) {
+        return undefined;
+    }
+    const reportPath = path.join(artifactDir, 'pipeline_report.json');
+    if (!fs.existsSync(reportPath)) {
+        return undefined;
+    }
+    try {
+        const report = readJson(reportPath);
+        const runStatus = String(report.run_status ?? '');
+        if (!['success', 'failed', 'stopped'].includes(runStatus)) {
+            return undefined;
+        }
+        return {
+            status: runStatus,
+            finished_at: job.finished_at || nowIso(),
+            exit_code: runStatus === 'success' ? 0 : 1,
+            last_error: redactText(String(report.error ?? job.last_error ?? ''))
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function reconcileFromRunDb(job) {
+    const artifactDir = String(job.artifact_dir ?? '');
+    if (!artifactDir) {
+        return undefined;
+    }
+    const runDbPath = path.join(artifactDir, 'run.db');
+    if (!fs.existsSync(runDbPath)) {
+        return undefined;
+    }
+    try {
+        const require = createRequire(import.meta.url);
+        const sqlite = require('node:sqlite');
+        const db = new sqlite.DatabaseSync(runDbPath);
+        try {
+            const row = db.prepare('SELECT status FROM runs ORDER BY run_id DESC LIMIT 1').get();
+            const runStatus = String(row?.status ?? '');
+            if (!['success', 'failed', 'stopped'].includes(runStatus)) {
+                return undefined;
+            }
+            return {
+                status: runStatus,
+                finished_at: job.finished_at || nowIso(),
+                exit_code: runStatus === 'success' ? 0 : 1
+            };
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeJob(job) {
+    const jobFile = String(job.job_file ?? '');
+    if (!jobFile) {
+        return;
+    }
+    job.updated_at = nowIso();
+    fs.writeFileSync(jobFile, `${JSON.stringify(job, null, 2)}\n`, 'utf8');
+}
+function reconcileJob(job) {
+    const events = lastJsonEvents(String(job.event_log ?? ''));
+    for (const event of events) {
+        job.last_event_at = nowIso();
+        if (event.type === 'run_started' && event.artifact_dir) {
+            job.artifact_dir = String(event.artifact_dir);
+        }
+        if (event.type === 'summary') {
+            job.artifact_dir = String(event.artifact_dir || job.artifact_dir || '');
+            const runStatus = String(event.run_status || '');
+            if (['success', 'failed', 'stopped'].includes(runStatus)) {
+                job.status = runStatus;
+                job.finished_at = job.finished_at || nowIso();
+                job.exit_code = runStatus === 'success' ? 0 : 1;
+            }
+            if (event.error) {
+                job.last_error = String(event.error);
+            }
+        }
+        if (event.type === 'run_failed') {
+            job.status = 'failed';
+            job.last_error = redactText(String(event.error || 'run failed'));
+            job.finished_at = job.finished_at || nowIso();
+            job.exit_code = 1;
+        }
+    }
+    if (['running', 'stopping'].includes(String(job.status ?? ''))) {
+        const reportStatus = reconcileFromPipelineReport(job);
+        if (reportStatus) {
+            Object.assign(job, reportStatus);
+        }
+        else {
+            const runDbStatus = reconcileFromRunDb(job);
+            if (runDbStatus) {
+                Object.assign(job, runDbStatus);
+            }
+        }
+    }
+    if (['running', 'stopping'].includes(String(job.status ?? '')) && !processAlive(Number(job.pid ?? 0))) {
+        if (job.status === 'stopping') {
+            job.status = 'stopped';
+        }
+        else if (!events.length) {
+            job.status = 'failed';
+            job.last_error = 'process exited without summary';
+        }
+        else {
+            job.status = 'failed';
+            job.last_error = job.last_error || 'process exited without terminal status';
+        }
+        job.finished_at = job.finished_at || nowIso();
+        if (job.exit_code === null || job.exit_code === undefined) {
+            job.exit_code = 1;
+        }
+    }
+    writeJob(job);
+    return job;
+}
+function loadIndex(projectRoot, env = process.env) {
+    const indexPath = path.join(jobsRoot(projectRoot, env), 'index.json');
+    if (!fs.existsSync(indexPath)) {
+        return { schema_version: 1, latest_job_id: '', jobs: [] };
+    }
+    return readJson(indexPath);
+}
+export function latestJobId(projectRoot, env = process.env) {
+    const jobId = String(loadIndex(projectRoot, env).latest_job_id ?? '');
+    if (!jobId) {
+        throw new Error('no jobs found');
+    }
+    return jobId;
+}
+export function activeJobIds(projectRoot, env = process.env) {
+    const index = loadIndex(projectRoot, env);
+    const active = [];
+    for (const item of (index.jobs ?? [])) {
+        try {
+            const job = loadJob(projectRoot, String(item.job_id ?? ''), env);
+            if (['running', 'stopping'].includes(String(job.status ?? '')) && processAlive(Number(job.pid ?? 0))) {
+                active.push(String(job.job_id));
+            }
+        }
+        catch {
+            // Ignore stale index rows that no longer have job metadata.
+        }
+    }
+    return active;
+}
+export function singleActiveJobId(projectRoot, env = process.env) {
+    const active = activeJobIds(projectRoot, env);
+    if (active.length > 1) {
+        throw new Error(`multiple active jobs: ${active.join(', ')}`);
+    }
+    if (!active.length) {
+        throw new Error('no active jobs');
+    }
+    return active[0];
+}
+export function loadJob(projectRoot, jobId, env = process.env) {
+    const jobPath = path.join(jobsRoot(projectRoot, env), jobId, 'job.json');
+    if (!fs.existsSync(jobPath)) {
+        throw new Error(`job not found: ${jobId}`);
+    }
+    return reconcileJob(readJson(jobPath));
+}
+export function publicJobPayload(job) {
+    const keys = [
+        'job_id',
+        'kind',
+        'status',
+        'pid',
+        'pgid',
+        'created_at',
+        'started_at',
+        'finished_at',
+        'exit_code',
+        'signal',
+        'project_root',
+        'event_log',
+        'human_log',
+        'stdout_log',
+        'stderr_log',
+        'artifact_dir',
+        'session_dir',
+        'options',
+        'retry',
+        'stop_requested_at',
+        'last_event_at',
+        'last_error',
+        'job_file'
+    ];
+    const payload = Object.fromEntries(keys.map((key) => [key, job[key]]));
+    if (payload.last_error) {
+        payload.last_error = redactText(String(payload.last_error));
+    }
+    return payload;
+}
+export function listJobs(projectRoot, env = process.env) {
+    const index = loadIndex(projectRoot, env);
+    const jobs = (index.jobs ?? [])
+        .map((item) => {
+        try {
+            const job = loadJob(projectRoot, String(item.job_id ?? ''), env);
+            return {
+                job_id: job.job_id,
+                status: job.status,
+                kind: job.kind,
+                created_at: job.created_at,
+                job_file: job.job_file
+            };
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter(Boolean);
+    return { ok: true, jobs, latest_job_id: index.latest_job_id ?? '' };
+}
+export function tailLog(projectRoot, jobId, argv, env = process.env) {
+    const job = loadJob(projectRoot, jobId, env);
+    const logFormat = readOptionValue(argv, '--format') ?? 'human';
+    const tail = Number.parseInt(readOptionValue(argv, '--tail') ?? '200', 10);
+    const logPath = String(logFormat === 'jsonl' ? job.event_log : job.human_log);
+    if (!fs.existsSync(logPath)) {
+        return '';
+    }
+    let lines = fs.readFileSync(logPath, 'utf8').split(/\r?\n/);
+    if (lines.at(-1) === '') {
+        lines = lines.slice(0, -1);
+    }
+    const selected = tail > 0 ? lines.slice(-tail) : lines;
+    return selected.length ? `${selected.join('\n')}\n` : '';
+}

package/dist/jobs/store.js

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { resolveProfilePath } from '../runtime/paths.js';
+function defaultNow() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, '+00:00');
+}
+function defaultJobId() {
+    const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/T/, '-').slice(0, 15);
+    return `${stamp}-${randomUUID().replace(/-/g, '').slice(0, 6)}`;
+}
+function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+function writeJson(filePath, payload) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.tmp`;
+    fs.writeFileSync(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    fs.renameSync(tmpPath, filePath);
+}
+export class JobStore {
+    projectRoot;
+    env;
+    now;
+    jobId;
+    constructor(projectRoot, options = {}) {
+        this.projectRoot = path.resolve(projectRoot);
+        this.env = options.env ?? process.env;
+        this.now = options.now ?? defaultNow;
+        this.jobId = options.jobId ?? defaultJobId;
+    }
+    jobsRoot() {
+        return path.join(path.dirname(resolveProfilePath(this.projectRoot, this.env)), 'jobs');
+    }
+    indexPath() {
+        return path.join(this.jobsRoot(), 'index.json');
+    }
+    loadIndex() {
+        if (!fs.existsSync(this.indexPath())) {
+            return { schema_version: 1, latest_job_id: '', jobs: [] };
+        }
+        return readJson(this.indexPath());
+    }
+    createRunningJob(input) {
+        const jobId = this.jobId();
+        const jobDir = path.join(this.jobsRoot(), jobId);
+        fs.mkdirSync(jobDir, { recursive: true });
+        const createdAt = this.now();
+        const job = {
+            schema_version: 1,
+            job_id: jobId,
+            kind: input.kind,
+            status: 'running',
+            pid: input.pid,
+            pgid: input.pid,
+            created_at: createdAt,
+            started_at: createdAt,
+            finished_at: '',
+            updated_at: createdAt,
+            exit_code: null,
+            signal: '',
+            project_root: this.projectRoot,
+            command: input.command,
+            event_log: path.join(jobDir, 'events.jsonl'),
+            human_log: path.join(jobDir, 'human.log'),
+            stdout_log: path.join(jobDir, 'stdout.log'),
+            stderr_log: path.join(jobDir, 'stderr.log'),
+            artifact_dir: '',
+            session_dir: jobDir,
+            resume_from: input.resumeFrom ?? '',
+            retry: input.retry ?? { source_artifact_dir: '', stage: '' },
+            options: input.options,
+            stop_requested_at: '',
+            last_event_at: '',
+            last_error: '',
+            job_file: path.join(jobDir, 'job.json')
+        };
+        for (const key of ['event_log', 'human_log', 'stdout_log', 'stderr_log']) {
+            fs.closeSync(fs.openSync(String(job[key]), 'a'));
+        }
+        return this.writeJob(job);
+    }
+    loadJob(jobId) {
+        const jobPath = path.join(this.jobsRoot(), jobId, 'job.json');
+        if (!fs.existsSync(jobPath)) {
+            throw new Error(`job not found: ${jobId}`);
+        }
+        return readJson(jobPath);
+    }
+    writeJob(job) {
+        job.updated_at = this.now();
+        writeJson(String(job.job_file), job);
+        this.updateIndex(job);
+        return job;
+    }
+    updateIndex(job) {
+        const index = this.loadIndex();
+        const jobs = (index.jobs ?? []).filter((item) => item.job_id !== job.job_id);
+        jobs.push({
+            job_id: job.job_id,
+            status: job.status,
+            kind: job.kind,
+            created_at: job.created_at,
+            job_file: job.job_file
+        });
+        writeJson(this.indexPath(), {
+            schema_version: 1,
+            latest_job_id: job.job_id,
+            jobs
+        });
+    }
+}
+export function createJobStore(projectRoot, options = {}) {
+    return new JobStore(projectRoot, options);
+}