@intent-systems/nexus 2026.1.5-3

package/dist/cron/parse.js

@@ -0,0 +1,24 @@
+const ISO_TZ_RE = /(Z|[+-]\d{2}:?\d{2})$/i;
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const ISO_DATE_TIME_RE = /^\d{4}-\d{2}-\d{2}T/;
+function normalizeUtcIso(raw) {
+    if (ISO_TZ_RE.test(raw))
+        return raw;
+    if (ISO_DATE_RE.test(raw))
+        return `${raw}T00:00:00Z`;
+    if (ISO_DATE_TIME_RE.test(raw))
+        return `${raw}Z`;
+    return raw;
+}
+export function parseAbsoluteTimeMs(input) {
+    const raw = input.trim();
+    if (!raw)
+        return null;
+    if (/^\d+$/.test(raw)) {
+        const n = Number(raw);
+        if (Number.isFinite(n) && n > 0)
+            return Math.floor(n);
+    }
+    const parsed = Date.parse(normalizeUtcIso(raw));
+    return Number.isFinite(parsed) ? parsed : null;
+}

package/dist/cron/run-log.js

@@ -0,0 +1,72 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export function resolveCronRunLogPath(params) {
+    const storePath = path.resolve(params.storePath);
+    const dir = path.dirname(storePath);
+    return path.join(dir, "runs", `${params.jobId}.jsonl`);
+}
+const writesByPath = new Map();
+async function pruneIfNeeded(filePath, opts) {
+    const stat = await fs.stat(filePath).catch(() => null);
+    if (!stat || stat.size <= opts.maxBytes)
+        return;
+    const raw = await fs.readFile(filePath, "utf-8").catch(() => "");
+    const lines = raw
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean);
+    const kept = lines.slice(Math.max(0, lines.length - opts.keepLines));
+    const tmp = `${filePath}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+    await fs.writeFile(tmp, `${kept.join("\n")}\n`, "utf-8");
+    await fs.rename(tmp, filePath);
+}
+export async function appendCronRunLog(filePath, entry, opts) {
+    const resolved = path.resolve(filePath);
+    const prev = writesByPath.get(resolved) ?? Promise.resolve();
+    const next = prev
+        .catch(() => undefined)
+        .then(async () => {
+        await fs.mkdir(path.dirname(resolved), { recursive: true });
+        await fs.appendFile(resolved, `${JSON.stringify(entry)}\n`, "utf-8");
+        await pruneIfNeeded(resolved, {
+            maxBytes: opts?.maxBytes ?? 2_000_000,
+            keepLines: opts?.keepLines ?? 2_000,
+        });
+    });
+    writesByPath.set(resolved, next);
+    await next;
+}
+export async function readCronRunLogEntries(filePath, opts) {
+    const limit = Math.max(1, Math.min(5000, Math.floor(opts?.limit ?? 200)));
+    const jobId = opts?.jobId?.trim() || undefined;
+    const raw = await fs
+        .readFile(path.resolve(filePath), "utf-8")
+        .catch(() => "");
+    if (!raw.trim())
+        return [];
+    const parsed = [];
+    const lines = raw.split("\n");
+    for (let i = lines.length - 1; i >= 0 && parsed.length < limit; i--) {
+        const line = lines[i]?.trim();
+        if (!line)
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            if (!obj || typeof obj !== "object")
+                continue;
+            if (obj.action !== "finished")
+                continue;
+            if (typeof obj.jobId !== "string" || obj.jobId.trim().length === 0)
+                continue;
+            if (typeof obj.ts !== "number" || !Number.isFinite(obj.ts))
+                continue;
+            if (jobId && obj.jobId !== jobId)
+                continue;
+            parsed.push(obj);
+        }
+        catch {
+            // ignore invalid lines
+        }
+    }
+    return parsed.reverse();
+}

package/dist/cron/schedule.js

@@ -0,0 +1,24 @@
+import { Cron } from "croner";
+export function computeNextRunAtMs(schedule, nowMs) {
+    if (schedule.kind === "at") {
+        return schedule.atMs > nowMs ? schedule.atMs : undefined;
+    }
+    if (schedule.kind === "every") {
+        const everyMs = Math.max(1, Math.floor(schedule.everyMs));
+        const anchor = Math.max(0, Math.floor(schedule.anchorMs ?? nowMs));
+        if (nowMs < anchor)
+            return anchor;
+        const elapsed = nowMs - anchor;
+        const steps = Math.max(1, Math.floor((elapsed + everyMs - 1) / everyMs));
+        return anchor + steps * everyMs;
+    }
+    const expr = schedule.expr.trim();
+    if (!expr)
+        return undefined;
+    const cron = new Cron(expr, {
+        timezone: schedule.tz?.trim() || undefined,
+        catch: false,
+    });
+    const next = cron.nextRun(new Date(nowMs));
+    return next ? next.getTime() : undefined;
+}

package/dist/cron/service.js

@@ -0,0 +1,471 @@
+import crypto from "node:crypto";
+import { computeNextRunAtMs } from "./schedule.js";
+import { loadCronStore, saveCronStore } from "./store.js";
+const STUCK_RUN_MS = 2 * 60 * 60 * 1000;
+function normalizeRequiredName(raw) {
+    if (typeof raw !== "string")
+        throw new Error("cron job name is required");
+    const name = raw.trim();
+    if (!name)
+        throw new Error("cron job name is required");
+    return name;
+}
+function normalizeOptionalText(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    const trimmed = raw.trim();
+    return trimmed ? trimmed : undefined;
+}
+function truncateText(input, maxLen) {
+    if (input.length <= maxLen)
+        return input;
+    return `${input.slice(0, Math.max(0, maxLen - 1)).trimEnd()}…`;
+}
+function inferLegacyName(job) {
+    const text = job?.payload?.kind === "systemEvent" && typeof job.payload.text === "string"
+        ? job.payload.text
+        : job?.payload?.kind === "agentTurn" &&
+            typeof job.payload.message === "string"
+            ? job.payload.message
+            : "";
+    const firstLine = text
+        .split("\n")
+        .map((l) => l.trim())
+        .find(Boolean) ?? "";
+    if (firstLine)
+        return truncateText(firstLine, 60);
+    const kind = typeof job?.schedule?.kind === "string" ? job.schedule.kind : "";
+    if (kind === "cron" && typeof job?.schedule?.expr === "string")
+        return `Cron: ${truncateText(job.schedule.expr, 52)}`;
+    if (kind === "every" && typeof job?.schedule?.everyMs === "number")
+        return `Every: ${job.schedule.everyMs}ms`;
+    if (kind === "at")
+        return "One-shot";
+    return "Cron job";
+}
+function normalizePayloadToSystemText(payload) {
+    if (payload.kind === "systemEvent")
+        return payload.text.trim();
+    return payload.message.trim();
+}
+export class CronService {
+    deps;
+    store = null;
+    timer = null;
+    running = false;
+    op = Promise.resolve();
+    warnedDisabled = false;
+    constructor(deps) {
+        this.deps = {
+            ...deps,
+            nowMs: deps.nowMs ?? (() => Date.now()),
+            onEvent: deps.onEvent,
+        };
+    }
+    async start() {
+        await this.locked(async () => {
+            if (!this.deps.cronEnabled) {
+                this.deps.log.info({ enabled: false }, "cron: disabled");
+                return;
+            }
+            await this.ensureLoaded();
+            this.recomputeNextRuns();
+            await this.persist();
+            this.armTimer();
+            this.deps.log.info({
+                enabled: true,
+                jobs: this.store?.jobs.length ?? 0,
+                nextWakeAtMs: this.nextWakeAtMs() ?? null,
+            }, "cron: started");
+        });
+    }
+    stop() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+    }
+    async status() {
+        return await this.locked(async () => {
+            await this.ensureLoaded();
+            return {
+                enabled: this.deps.cronEnabled,
+                storePath: this.deps.storePath,
+                jobs: this.store?.jobs.length ?? 0,
+                nextWakeAtMs: this.deps.cronEnabled === true ? (this.nextWakeAtMs() ?? null) : null,
+            };
+        });
+    }
+    async list(opts) {
+        return await this.locked(async () => {
+            await this.ensureLoaded();
+            const includeDisabled = opts?.includeDisabled === true;
+            const jobs = (this.store?.jobs ?? []).filter((j) => includeDisabled || j.enabled);
+            return jobs.sort((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0));
+        });
+    }
+    async add(input) {
+        return await this.locked(async () => {
+            this.warnIfDisabled("add");
+            await this.ensureLoaded();
+            const now = this.deps.nowMs();
+            const id = crypto.randomUUID();
+            const job = {
+                id,
+                name: normalizeRequiredName(input.name),
+                description: normalizeOptionalText(input.description),
+                enabled: input.enabled !== false,
+                createdAtMs: now,
+                updatedAtMs: now,
+                schedule: input.schedule,
+                sessionTarget: input.sessionTarget,
+                wakeMode: input.wakeMode,
+                payload: input.payload,
+                isolation: input.isolation,
+                state: {
+                    ...input.state,
+                },
+            };
+            this.assertSupportedJobSpec(job);
+            job.state.nextRunAtMs = this.computeJobNextRunAtMs(job, now);
+            this.store?.jobs.push(job);
+            await this.persist();
+            this.armTimer();
+            this.emit({
+                jobId: id,
+                action: "added",
+                nextRunAtMs: job.state.nextRunAtMs,
+            });
+            return job;
+        });
+    }
+    async update(id, patch) {
+        return await this.locked(async () => {
+            this.warnIfDisabled("update");
+            await this.ensureLoaded();
+            const job = this.findJobOrThrow(id);
+            const now = this.deps.nowMs();
+            if ("name" in patch)
+                job.name = normalizeRequiredName(patch.name);
+            if ("description" in patch)
+                job.description = normalizeOptionalText(patch.description);
+            if (typeof patch.enabled === "boolean")
+                job.enabled = patch.enabled;
+            if (patch.schedule)
+                job.schedule = patch.schedule;
+            if (patch.sessionTarget)
+                job.sessionTarget = patch.sessionTarget;
+            if (patch.wakeMode)
+                job.wakeMode = patch.wakeMode;
+            if (patch.payload)
+                job.payload = patch.payload;
+            if (patch.isolation)
+                job.isolation = patch.isolation;
+            if (patch.state)
+                job.state = { ...job.state, ...patch.state };
+            job.updatedAtMs = now;
+            this.assertSupportedJobSpec(job);
+            if (job.enabled) {
+                job.state.nextRunAtMs = this.computeJobNextRunAtMs(job, now);
+            }
+            else {
+                job.state.nextRunAtMs = undefined;
+                job.state.runningAtMs = undefined;
+            }
+            await this.persist();
+            this.armTimer();
+            this.emit({
+                jobId: id,
+                action: "updated",
+                nextRunAtMs: job.state.nextRunAtMs,
+            });
+            return job;
+        });
+    }
+    async remove(id) {
+        return await this.locked(async () => {
+            this.warnIfDisabled("remove");
+            await this.ensureLoaded();
+            const before = this.store?.jobs.length ?? 0;
+            if (!this.store)
+                return { ok: false, removed: false };
+            this.store.jobs = this.store.jobs.filter((j) => j.id !== id);
+            const removed = (this.store.jobs.length ?? 0) !== before;
+            await this.persist();
+            this.armTimer();
+            if (removed)
+                this.emit({ jobId: id, action: "removed" });
+            return { ok: true, removed };
+        });
+    }
+    async run(id, mode) {
+        return await this.locked(async () => {
+            this.warnIfDisabled("run");
+            await this.ensureLoaded();
+            const job = this.findJobOrThrow(id);
+            const now = this.deps.nowMs();
+            const due = mode === "force" ||
+                (job.enabled &&
+                    typeof job.state.nextRunAtMs === "number" &&
+                    now >= job.state.nextRunAtMs);
+            if (!due)
+                return { ok: true, ran: false, reason: "not-due" };
+            await this.executeJob(job, now, { forced: mode === "force" });
+            await this.persist();
+            this.armTimer();
+            return { ok: true, ran: true };
+        });
+    }
+    wake(opts) {
+        const text = opts.text.trim();
+        if (!text)
+            return { ok: false };
+        this.deps.enqueueSystemEvent(text);
+        if (opts.mode === "now") {
+            this.deps.requestHeartbeatNow({ reason: "wake" });
+        }
+        return { ok: true };
+    }
+    async locked(fn) {
+        const next = this.op.then(fn, fn);
+        // Keep the chain alive even when the operation fails.
+        this.op = next.then(() => undefined, () => undefined);
+        return (await next);
+    }
+    async ensureLoaded() {
+        if (this.store)
+            return;
+        const loaded = await loadCronStore(this.deps.storePath);
+        const jobs = (loaded.jobs ?? []);
+        let mutated = false;
+        for (const raw of jobs) {
+            const nameRaw = raw.name;
+            if (typeof nameRaw !== "string" || nameRaw.trim().length === 0) {
+                raw.name = inferLegacyName({
+                    schedule: raw.schedule,
+                    payload: raw.payload,
+                });
+                mutated = true;
+            }
+            else {
+                raw.name = nameRaw.trim();
+            }
+            const desc = normalizeOptionalText(raw.description);
+            if (raw.description !== desc) {
+                raw.description = desc;
+                mutated = true;
+            }
+        }
+        this.store = { version: 1, jobs: jobs };
+        if (mutated)
+            await this.persist();
+    }
+    warnIfDisabled(action) {
+        if (this.deps.cronEnabled)
+            return;
+        if (this.warnedDisabled)
+            return;
+        this.warnedDisabled = true;
+        this.deps.log.warn({ enabled: false, action, storePath: this.deps.storePath }, "cron: scheduler disabled; jobs will not run automatically");
+    }
+    async persist() {
+        if (!this.store)
+            return;
+        await saveCronStore(this.deps.storePath, this.store);
+    }
+    findJobOrThrow(id) {
+        const job = this.store?.jobs.find((j) => j.id === id);
+        if (!job)
+            throw new Error(`unknown cron job id: ${id}`);
+        return job;
+    }
+    computeJobNextRunAtMs(job, nowMs) {
+        if (!job.enabled)
+            return undefined;
+        if (job.schedule.kind === "at") {
+            // One-shot jobs stay due until they successfully finish.
+            if (job.state.lastStatus === "ok" && job.state.lastRunAtMs)
+                return undefined;
+            return job.schedule.atMs;
+        }
+        return computeNextRunAtMs(job.schedule, nowMs);
+    }
+    recomputeNextRuns() {
+        if (!this.store)
+            return;
+        const now = this.deps.nowMs();
+        for (const job of this.store.jobs) {
+            if (!job.state)
+                job.state = {};
+            if (!job.enabled) {
+                job.state.nextRunAtMs = undefined;
+                job.state.runningAtMs = undefined;
+                continue;
+            }
+            const runningAt = job.state.runningAtMs;
+            if (typeof runningAt === "number" && now - runningAt > STUCK_RUN_MS) {
+                this.deps.log.warn({ jobId: job.id, runningAtMs: runningAt }, "cron: clearing stuck running marker");
+                job.state.runningAtMs = undefined;
+            }
+            job.state.nextRunAtMs = this.computeJobNextRunAtMs(job, now);
+        }
+    }
+    nextWakeAtMs() {
+        const jobs = this.store?.jobs ?? [];
+        const enabled = jobs.filter((j) => j.enabled && typeof j.state.nextRunAtMs === "number");
+        if (enabled.length === 0)
+            return undefined;
+        return enabled.reduce((min, j) => Math.min(min, j.state.nextRunAtMs), enabled[0].state.nextRunAtMs);
+    }
+    armTimer() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        if (!this.deps.cronEnabled)
+            return;
+        const nextAt = this.nextWakeAtMs();
+        if (!nextAt)
+            return;
+        const delay = Math.max(nextAt - this.deps.nowMs(), 0);
+        this.timer = setTimeout(() => {
+            void this.onTimer().catch((err) => {
+                this.deps.log.error({ err: String(err) }, "cron: timer tick failed");
+            });
+        }, delay);
+        this.timer.unref?.();
+    }
+    async onTimer() {
+        if (this.running)
+            return;
+        this.running = true;
+        try {
+            await this.locked(async () => {
+                await this.ensureLoaded();
+                await this.runDueJobs();
+                await this.persist();
+                this.armTimer();
+            });
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async runDueJobs() {
+        if (!this.store)
+            return;
+        const now = this.deps.nowMs();
+        const due = this.store.jobs.filter((j) => {
+            if (!j.enabled)
+                return false;
+            if (typeof j.state.runningAtMs === "number")
+                return false;
+            const next = j.state.nextRunAtMs;
+            return typeof next === "number" && now >= next;
+        });
+        for (const job of due) {
+            await this.executeJob(job, now, { forced: false });
+        }
+    }
+    async executeJob(job, nowMs, opts) {
+        const startedAt = this.deps.nowMs();
+        job.state.runningAtMs = startedAt;
+        job.state.lastError = undefined;
+        this.emit({ jobId: job.id, action: "started", runAtMs: startedAt });
+        const finish = async (status, err, summary) => {
+            const endedAt = this.deps.nowMs();
+            job.state.runningAtMs = undefined;
+            job.state.lastRunAtMs = startedAt;
+            job.state.lastStatus = status;
+            job.state.lastDurationMs = Math.max(0, endedAt - startedAt);
+            job.state.lastError = err;
+            if (job.schedule.kind === "at" && status === "ok") {
+                // One-shot job completed successfully; disable it.
+                job.enabled = false;
+                job.state.nextRunAtMs = undefined;
+            }
+            else if (job.enabled) {
+                job.state.nextRunAtMs = this.computeJobNextRunAtMs(job, endedAt);
+            }
+            else {
+                job.state.nextRunAtMs = undefined;
+            }
+            this.emit({
+                jobId: job.id,
+                action: "finished",
+                status,
+                error: err,
+                summary,
+                runAtMs: startedAt,
+                durationMs: job.state.lastDurationMs,
+                nextRunAtMs: job.state.nextRunAtMs,
+            });
+            if (job.sessionTarget === "isolated") {
+                const prefix = job.isolation?.postToMainPrefix?.trim() || "Cron";
+                const body = (summary ?? err ?? status).trim();
+                const statusPrefix = status === "ok" ? prefix : `${prefix} (${status})`;
+                this.deps.enqueueSystemEvent(`${statusPrefix}: ${body}`);
+                if (job.wakeMode === "now") {
+                    this.deps.requestHeartbeatNow({ reason: `cron:${job.id}:post` });
+                }
+            }
+        };
+        try {
+            if (job.sessionTarget === "main") {
+                if (job.payload.kind !== "systemEvent") {
+                    await finish("skipped", 'main job requires payload.kind="systemEvent"');
+                    return;
+                }
+                const text = normalizePayloadToSystemText(job.payload);
+                if (!text) {
+                    await finish("skipped", "main job requires non-empty systemEvent text");
+                    return;
+                }
+                this.deps.enqueueSystemEvent(text);
+                if (job.wakeMode === "now") {
+                    this.deps.requestHeartbeatNow({ reason: `cron:${job.id}` });
+                }
+                await finish("ok", undefined, text);
+                return;
+            }
+            if (job.payload.kind !== "agentTurn") {
+                await finish("skipped", "isolated job requires payload.kind=agentTurn");
+                return;
+            }
+            const res = await this.deps.runIsolatedAgentJob({
+                job,
+                message: job.payload.message,
+            });
+            if (res.status === "ok")
+                await finish("ok", undefined, res.summary);
+            else if (res.status === "skipped")
+                await finish("skipped", undefined, res.summary);
+            else
+                await finish("error", res.error ?? "cron job failed", res.summary);
+        }
+        catch (err) {
+            await finish("error", String(err));
+        }
+        finally {
+            job.updatedAtMs = nowMs;
+            if (!opts.forced && job.enabled) {
+                // Keep nextRunAtMs in sync in case the schedule advanced during a long run.
+                job.state.nextRunAtMs = this.computeJobNextRunAtMs(job, this.deps.nowMs());
+            }
+        }
+    }
+    emit(evt) {
+        try {
+            this.deps.onEvent?.(evt);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    assertSupportedJobSpec(job) {
+        if (job.sessionTarget === "main" && job.payload.kind !== "systemEvent") {
+            throw new Error('main cron jobs require payload.kind="systemEvent"');
+        }
+        if (job.sessionTarget === "isolated" && job.payload.kind !== "agentTurn") {
+            throw new Error('isolated cron jobs require payload.kind="agentTurn"');
+        }
+    }
+}

package/dist/cron/store.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import JSON5 from "json5";
+import { CONFIG_DIR } from "../utils.js";
+export const DEFAULT_CRON_DIR = path.join(CONFIG_DIR, "cron");
+export const DEFAULT_CRON_STORE_PATH = path.join(DEFAULT_CRON_DIR, "jobs.json");
+export function resolveCronStorePath(storePath) {
+    if (storePath?.trim()) {
+        const raw = storePath.trim();
+        if (raw.startsWith("~"))
+            return path.resolve(raw.replace("~", os.homedir()));
+        return path.resolve(raw);
+    }
+    return DEFAULT_CRON_STORE_PATH;
+}
+export async function loadCronStore(storePath) {
+    try {
+        const raw = await fs.promises.readFile(storePath, "utf-8");
+        const parsed = JSON5.parse(raw);
+        const jobs = Array.isArray(parsed?.jobs) ? parsed?.jobs : [];
+        return {
+            version: 1,
+            jobs: jobs.filter(Boolean),
+        };
+    }
+    catch {
+        return { version: 1, jobs: [] };
+    }
+}
+export async function saveCronStore(storePath, store) {
+    await fs.promises.mkdir(path.dirname(storePath), { recursive: true });
+    const tmp = `${storePath}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+    const json = JSON.stringify(store, null, 2);
+    await fs.promises.writeFile(tmp, json, "utf-8");
+    await fs.promises.rename(tmp, storePath);
+    try {
+        await fs.promises.copyFile(storePath, `${storePath}.bak`);
+    }
+    catch {
+        // best-effort
+    }
+}

package/dist/cron/types.js

@@ -0,0 +1 @@
+export {};

package/dist/daemon/constants.js

@@ -0,0 +1,10 @@
+export const GATEWAY_LAUNCH_AGENT_LABEL = "com.nexus.gateway";
+export const GATEWAY_SYSTEMD_SERVICE_NAME = "nexus-gateway";
+export const GATEWAY_WINDOWS_TASK_NAME = "Nexus Gateway";
+export const LEGACY_GATEWAY_LAUNCH_AGENT_LABELS = [
+    "com.steipete.nexus.gateway",
+    "com.steipete.nexus.gateway",
+    "com.nexus.gateway",
+];
+export const LEGACY_GATEWAY_SYSTEMD_SERVICE_NAMES = ["nexus-gateway"];
+export const LEGACY_GATEWAY_WINDOWS_TASK_NAMES = ["Nexus Gateway"];