pi-crew 0.2.3 → 0.2.5

package/src/runtime/runtime-resolver.ts

@@ -1,91 +1,94 @@
-import type { PiTeamsConfig } from "../config/config.ts";
-import type { RuntimeResolutionState } from "../state/types.ts";
-import type { CrewRuntimeKind } from "./crew-agent-runtime.ts";
-
-export type CrewRuntimeMode = "auto" | "scaffold" | "child-process" | "live-session";
-
-export type CrewRuntimeSafety = "trusted" | "explicit_dry_run" | "blocked";
-
-export interface CrewRuntimeCapabilities {
-	kind: CrewRuntimeKind;
-	requestedMode: CrewRuntimeMode;
-	available: boolean;
-	fallback?: CrewRuntimeKind;
-	steer: boolean;
-	resume: boolean;
-	liveToolActivity: boolean;
-	transcript: boolean;
-	reason?: string;
-	safety: CrewRuntimeSafety;
-}
-
-export function runtimeResolutionState(runtime: CrewRuntimeCapabilities, resolvedAt = new Date().toISOString()): RuntimeResolutionState {
-	return {
-		kind: runtime.kind,
-		requestedMode: runtime.requestedMode,
-		safety: runtime.safety,
-		available: runtime.available,
-		...(runtime.fallback ? { fallback: runtime.fallback } : {}),
-		...(runtime.reason ? { reason: runtime.reason } : {}),
-		resolvedAt,
-	};
-}
-
-export async function isLiveSessionRuntimeAvailable(timeoutMs = 1500, env: NodeJS.ProcessEnv = process.env): Promise<{ available: boolean; reason?: string }> {
-	if (env.PI_CREW_MOCK_LIVE_SESSION === "success") {
-		return { available: true, reason: "Mock live-session runtime is enabled." };
-	}
-	const probe = async (): Promise<{ available: boolean; reason?: string }> => {
-		try {
-			// LAZY: optional peer dependency — probe at runtime to avoid hard dependency.
-			const mod = await import("@mariozechner/pi-coding-agent");
-			const api = mod as Record<string, unknown>;
-			const required = ["createAgentSession", "DefaultResourceLoader", "SessionManager", "SettingsManager"];
-			const missing = required.filter((name) => typeof api[name] === "undefined");
-			if (missing.length) return { available: false, reason: `Pi SDK live-session exports missing: ${missing.join(", ")}.` };
-			return { available: true };
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			return { available: false, reason: `Could not load optional Pi SDK live-session runtime: ${message}` };
-		}
-	};
-	let timer: NodeJS.Timeout | undefined;
-	try {
-		return await Promise.race([
-			probe(),
-			new Promise<{ available: boolean; reason: string }>((resolve) => {
-				timer = setTimeout(() => resolve({ available: false, reason: `Timed out probing optional Pi SDK live-session runtime after ${timeoutMs}ms.` }), timeoutMs);
-				timer.unref();
-			}),
-		]);
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-
-export async function resolveCrewRuntime(config: PiTeamsConfig, env: NodeJS.ProcessEnv = process.env): Promise<CrewRuntimeCapabilities> {
-	const requestedMode = config.runtime?.mode ?? "auto";
-	const workersDisabled = config.executeWorkers === false || env.PI_CREW_EXECUTE_WORKERS === "0" || env.PI_TEAMS_EXECUTE_WORKERS === "0";
-	if (requestedMode === "scaffold") return scaffoldCaps(requestedMode, undefined, "explicit_dry_run");
-	if (workersDisabled) return scaffoldCaps(requestedMode, "Child worker execution disabled by config/env. Set runtime.mode=scaffold or executeWorkers=false only for dry runs.", "blocked");
-	if (requestedMode === "child-process") return childCaps(requestedMode);
-	if (requestedMode === "live-session" || (requestedMode === "auto" && config.runtime?.preferLiveSession === true)) {
-		const live = await isLiveSessionRuntimeAvailable(1500, env);
-		if (live.available) return liveCaps(requestedMode);
-		if (requestedMode === "live-session" && config.runtime?.allowChildProcessFallback === false) return scaffoldCaps(requestedMode, live.reason, "blocked");
-		return { ...childCaps(requestedMode), fallback: "child-process", reason: live.reason };
-	}
-	return childCaps(requestedMode);
-}
-
-function scaffoldCaps(requestedMode: CrewRuntimeMode, reason?: string, safety: CrewRuntimeSafety = "explicit_dry_run"): CrewRuntimeCapabilities {
-	return { kind: "scaffold", requestedMode, available: safety !== "blocked", steer: false, resume: false, liveToolActivity: false, transcript: false, safety, ...(reason ? { reason } : {}) };
-}
-
-function childCaps(requestedMode: CrewRuntimeMode, reason?: string): CrewRuntimeCapabilities {
-	return { kind: "child-process", requestedMode, available: true, steer: false, resume: false, liveToolActivity: false, transcript: true, safety: "trusted", ...(reason ? { reason } : {}) };
-}
-
-function liveCaps(requestedMode: CrewRuntimeMode): CrewRuntimeCapabilities {
-	return { kind: "live-session", requestedMode, available: true, steer: true, resume: true, liveToolActivity: true, transcript: true, safety: "trusted" };
-}
+import type { PiTeamsConfig } from "../config/config.ts";
+import type { RuntimeResolutionState } from "../state/types.ts";
+import type { CrewRuntimeKind } from "./crew-agent-runtime.ts";
+
+export type CrewRuntimeMode = "auto" | "scaffold" | "child-process" | "live-session";
+
+export type CrewRuntimeSafety = "trusted" | "explicit_dry_run" | "blocked";
+
+export interface CrewRuntimeCapabilities {
+	kind: CrewRuntimeKind;
+	requestedMode: CrewRuntimeMode;
+	available: boolean;
+	fallback?: CrewRuntimeKind;
+	steer: boolean;
+	resume: boolean;
+	liveToolActivity: boolean;
+	transcript: boolean;
+	reason?: string;
+	safety: CrewRuntimeSafety;
+}
+
+export function runtimeResolutionState(runtime: CrewRuntimeCapabilities, resolvedAt = new Date().toISOString()): RuntimeResolutionState {
+	return {
+		kind: runtime.kind,
+		requestedMode: runtime.requestedMode,
+		safety: runtime.safety,
+		available: runtime.available,
+		...(runtime.fallback ? { fallback: runtime.fallback } : {}),
+		...(runtime.reason ? { reason: runtime.reason } : {}),
+		resolvedAt,
+	};
+}
+
+export async function isLiveSessionRuntimeAvailable(timeoutMs = 1500, env: NodeJS.ProcessEnv = process.env): Promise<{ available: boolean; reason?: string }> {
+	if (env.PI_CREW_MOCK_LIVE_SESSION === "success") {
+		return { available: true, reason: "Mock live-session runtime is enabled." };
+	}
+	const probe = async (): Promise<{ available: boolean; reason?: string }> => {
+		try {
+			// LAZY: optional peer dependency — probe at runtime to avoid hard dependency.
+			const mod = await import("@mariozechner/pi-coding-agent");
+			const api = mod as Record<string, unknown>;
+			const required = ["createAgentSession", "DefaultResourceLoader", "SessionManager", "SettingsManager"];
+			const missing = required.filter((name) => typeof api[name] === "undefined");
+			if (missing.length) return { available: false, reason: `Pi SDK live-session exports missing: ${missing.join(", ")}.` };
+			return { available: true };
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return { available: false, reason: `Could not load optional Pi SDK live-session runtime: ${message}` };
+		}
+	};
+	let timer: NodeJS.Timeout | undefined;
+	try {
+		return await Promise.race([
+			probe(),
+			new Promise<{ available: boolean; reason: string }>((resolve) => {
+				timer = setTimeout(() => resolve({ available: false, reason: `Timed out probing optional Pi SDK live-session runtime after ${timeoutMs}ms.` }), timeoutMs);
+				timer.unref();
+			}),
+		]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+
+export async function resolveCrewRuntime(config: PiTeamsConfig, env: NodeJS.ProcessEnv = process.env): Promise<CrewRuntimeCapabilities> {
+	const requestedMode = config.runtime?.mode ?? "auto";
+	const workersDisabled = config.executeWorkers === false || env.PI_CREW_EXECUTE_WORKERS === "0" || env.PI_TEAMS_EXECUTE_WORKERS === "0";
+	if (requestedMode === "scaffold") return scaffoldCaps(requestedMode, undefined, "explicit_dry_run");
+	if (workersDisabled) return scaffoldCaps(requestedMode, "Child worker execution disabled by config/env. Set runtime.mode=scaffold or executeWorkers=false only for dry runs.", "blocked");
+	if (requestedMode === "child-process") return childCaps(requestedMode);
+	// When a child-process mock is active (tests), force auto-mode to child-process where the mock is active.
+	if (requestedMode === "auto" && env.PI_TEAMS_MOCK_CHILD_PI) return childCaps(requestedMode, "PI_TEAMS_MOCK_CHILD_PI mock forces child-process runtime in auto mode.");
+	if (requestedMode === "live-session" || requestedMode === "auto") {
+		const live = await isLiveSessionRuntimeAvailable(1500, env);
+		if (live.available) return liveCaps(requestedMode);
+		if (requestedMode === "live-session" && config.runtime?.allowChildProcessFallback === false)
+			return scaffoldCaps(requestedMode, live.reason, "blocked");
+		return { ...childCaps(requestedMode), fallback: "child-process", reason: live.reason };
+	}
+	return childCaps(requestedMode);
+}
+
+function scaffoldCaps(requestedMode: CrewRuntimeMode, reason?: string, safety: CrewRuntimeSafety = "explicit_dry_run"): CrewRuntimeCapabilities {
+	return { kind: "scaffold", requestedMode, available: safety !== "blocked", steer: false, resume: false, liveToolActivity: false, transcript: false, safety, ...(reason ? { reason } : {}) };
+}
+
+function childCaps(requestedMode: CrewRuntimeMode, reason?: string): CrewRuntimeCapabilities {
+	return { kind: "child-process", requestedMode, available: true, steer: false, resume: false, liveToolActivity: false, transcript: true, safety: "trusted", ...(reason ? { reason } : {}) };
+}
+
+function liveCaps(requestedMode: CrewRuntimeMode): CrewRuntimeCapabilities {
+	return { kind: "live-session", requestedMode, available: true, steer: true, resume: true, liveToolActivity: true, transcript: true, safety: "trusted" };
+}

package/src/runtime/scheduler.ts

@@ -0,0 +1,294 @@
+export type ScheduleType = "cron" | "once" | "interval";
+
+export interface ScheduledJob {
+	id: string;
+	name: string;
+	description: string;
+	schedule: string;
+	scheduleType: ScheduleType;
+	intervalMs?: number;
+	subagentType: string;
+	prompt: string;
+	enabled: boolean;
+	createdAt: string;
+	lastRun?: string;
+	lastStatus?: "success" | "error" | "running";
+	nextRun?: string;
+	runCount: number;
+}
+
+export type ScheduleChangeEvent =
+	| { type: "added"; job: ScheduledJob }
+	| { type: "removed"; jobId: string }
+	| { type: "updated"; job: ScheduledJob }
+	| { type: "fired"; jobId: string; agentId: string; name: string }
+	| { type: "error"; jobId: string; error: string };
+
+export class CrewScheduler {
+	private jobs = new Map<string, ScheduledJob>();
+	private timers = new Map<string, ReturnType<typeof setInterval | typeof setTimeout>>();
+	private emit?: (event: ScheduleChangeEvent) => void;
+	private executor?: (job: ScheduledJob) => string;
+	private finalizer?: (jobId: string, agentId: string) => void;
+
+	start(
+		options: {
+			emit: (event: ScheduleChangeEvent) => void;
+			executor: (job: ScheduledJob) => string;
+			finalizer: (jobId: string, agentId: string) => void;
+		},
+	): void {
+		this.emit = options.emit;
+		this.executor = options.executor;
+		this.finalizer = options.finalizer;
+	}
+
+	stop(): void {
+		for (const t of this.timers.values()) {
+			clearInterval(t as ReturnType<typeof setInterval>);
+			clearTimeout(t as ReturnType<typeof setTimeout>);
+		}
+		this.timers.clear();
+		this.emit = undefined;
+		this.executor = undefined;
+		this.finalizer = undefined;
+	}
+
+	add(job: ScheduledJob): void {
+		this.jobs.set(job.id, job);
+		if (job.enabled) this.arm(job);
+		this.emit?.({ type: "added", job });
+	}
+
+	remove(id: string): boolean {
+		this.disarm(id);
+		const ok = this.jobs.delete(id);
+		if (ok) this.emit?.({ type: "removed", jobId: id });
+		return ok;
+	}
+
+	update(id: string, patch: Partial<ScheduledJob>): ScheduledJob | undefined {
+		const existing = this.jobs.get(id);
+		if (!existing) return undefined;
+		this.disarm(id);
+		const updated = { ...existing, ...patch };
+		this.jobs.set(id, updated);
+		if (updated.enabled) this.arm(updated);
+		this.emit?.({ type: "updated", job: updated });
+		return updated;
+	}
+
+	list(): ScheduledJob[] {
+		return [...this.jobs.values()];
+	}
+
+	private arm(job: ScheduledJob): void {
+		if (this.timers.has(job.id)) return;
+		if (job.scheduleType === "interval" && job.intervalMs) {
+			const t = setInterval(() => this.fire(job.id), job.intervalMs);
+			this.timers.set(job.id, t);
+		} else if (job.scheduleType === "once") {
+			const target = new Date(job.schedule).getTime();
+			const delay = target - Date.now();
+			if (delay > 0) {
+				const t = setTimeout(() => {
+					this.fire(job.id);
+					this.update(job.id, { enabled: false });
+				}, delay);
+				this.timers.set(job.id, t);
+			} else {
+				this.update(job.id, { enabled: false, lastStatus: "error" });
+				this.emit?.({ type: "error", jobId: job.id, error: `Scheduled time ${job.schedule} is in the past` });
+			}
+		}
+	}
+
+	private disarm(id: string): void {
+		const t = this.timers.get(id);
+		if (t) {
+			clearInterval(t as ReturnType<typeof setInterval>);
+			clearTimeout(t as ReturnType<typeof setTimeout>);
+			this.timers.delete(id);
+		}
+	}
+
+	private fire(id: string): void {
+		const job = this.jobs.get(id);
+		if (!job?.enabled || !this.executor) return;
+		this.update(id, { lastStatus: "running" });
+		let agentId: string;
+		try {
+			agentId = this.executor(job);
+		} catch (err) {
+			const error = err instanceof Error ? err.message : String(err);
+			this.update(id, { lastRun: new Date().toISOString(), lastStatus: "error" });
+			this.emit?.({ type: "error", jobId: id, error });
+			return;
+		}
+		this.emit?.({ type: "fired", jobId: id, agentId, name: job.name });
+		this.finalizer?.(id, agentId);
+	}
+
+	static detectSchedule(s: string): { type: ScheduleType; intervalMs?: number; normalized: string } {
+		const trimmed = s.trim();
+		// Relative: +10m
+		const rel = trimmed.match(/^\+(\d+)(s|m|h|d)$/);
+		if (rel) {
+			const ms = parseInt(rel[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[rel[2] as "s" | "m" | "h" | "d"];
+			return { type: "once", normalized: new Date(Date.now() + ms).toISOString() };
+		}
+		// Interval: 5m
+		const ivl = trimmed.match(/^(\d+)(s|m|h|d)$/);
+		if (ivl) {
+			const ms = parseInt(ivl[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[ivl[2] as "s" | "m" | "h" | "d"];
+			return { type: "interval", intervalMs: ms, normalized: trimmed };
+		}
+		// ISO timestamp
+		if (/^\d{4}-\d{2}-\d{2}T/.test(trimmed)) {
+			const d = new Date(trimmed);
+			if (!Number.isNaN(d.getTime())) {
+				if (d.getTime() <= Date.now()) throw new Error(`Scheduled time ${d.toISOString()} is in the past.`);
+				return { type: "once", normalized: d.toISOString() };
+			}
+		}
+		// Simple cron-like (5 fields)
+		const cronFields = trimmed.split(/\s+/);
+		if (cronFields.length >= 5) {
+			return { type: "cron", normalized: trimmed };
+		}
+		throw new Error(`Invalid schedule "${s}". Use "5m", "+10m", ISO timestamp, or cron expression.`);
+	}
+}
+
+export interface ScheduleSpec {
+	kind: "once" | "interval" | "cron";
+	spec: string;
+}
+
+function parseIntervalMs(s: string): number | undefined {
+	let ms = 0;
+	let remaining = s;
+	const unitMs: Record<string, number> = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+	while (remaining.length > 0) {
+		const m = remaining.match(/^(\d+)(s|m|h|d)/);
+		if (!m) return undefined;
+		ms += parseInt(m[1], 10) * unitMs[m[2]];
+		remaining = remaining.slice(m[0].length);
+	}
+	return ms;
+}
+
+function nextCronDate(spec: string, from: Date): Date | { error: string } | null {
+	const parts = spec.split(/\s+/);
+	if (parts.length < 5) return { error: "Invalid cron expression" };
+	const [minStr, hourStr, domStr, monthStr, dowStr] = parts;
+
+	function matchField(value: number, str: string, min: number, max: number): boolean {
+		if (str === "*") return true;
+		const n = parseInt(str, 10);
+		if (!Number.isNaN(n) && n >= min && n <= max && n === value) return true;
+		if (/^\d+-\d+$/.test(str)) {
+			const [a, b] = str.split("-").map(Number);
+			return value >= a && value <= b;
+		}
+		if (str.includes(",")) {
+			return str.split(",").some((part) => matchField(value, part.trim(), min, max));
+		}
+		return false;
+	}
+
+	let cursor = new Date(from.getTime());
+	cursor.setSeconds(0, 0);
+	cursor = new Date(cursor.getTime() + 60_000);
+
+	const maxIterations = 366 * 24 * 60;
+	for (let i = 0; i < maxIterations; i++) {
+		const min = cursor.getUTCMinutes();
+		const hour = cursor.getUTCHours();
+		const dom = cursor.getUTCDate();
+		const month = cursor.getUTCMonth() + 1;
+		const dow = cursor.getUTCDay();
+
+		if (
+			matchField(min, minStr, 0, 59) &&
+			matchField(hour, hourStr, 0, 23) &&
+			matchField(dom, domStr, 1, 31) &&
+			matchField(month, monthStr, 1, 12) &&
+			matchField(dow, dowStr, 0, 6)
+		) {
+			return cursor;
+		}
+
+		cursor = new Date(cursor.getTime() + 60_000);
+	}
+
+	return { error: "No next cron occurrence found within search window" };
+}
+
+export function parseSchedule(spec: string): ScheduleSpec | { error: string } {
+	const trimmed = spec.trim();
+	if (/^\d{4}-\d{2}-\d{2}T/.test(trimmed)) {
+		const d = new Date(trimmed);
+		if (!Number.isNaN(d.getTime())) {
+			return { kind: "once", spec: trimmed };
+		}
+	}
+	if (/^\+\d+(s|m|h|d)$/.test(trimmed)) {
+		return { kind: "once", spec: trimmed };
+	}
+	const ivlMs = parseIntervalMs(trimmed);
+	if (ivlMs !== undefined && ivlMs > 0) {
+		return { kind: "interval", spec: trimmed };
+	}
+	const fields = trimmed.split(/\s+/);
+	if (fields.length >= 5) {
+		return { kind: "cron", spec: trimmed };
+	}
+	return { error: `Invalid schedule "${spec}". Use "5m", "+10m", ISO timestamp, or cron expression.` };
+}
+
+export function nextRunTime(spec: ScheduleSpec, from: Date = new Date()): Date | { error: string } {
+	if (spec.kind === "once") {
+		const rel = spec.spec.match(/^\+(\d+)(s|m|h|d)$/);
+		if (rel) {
+			const ms = parseInt(rel[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[rel[2] as "s" | "m" | "h" | "d"];
+			return new Date(from.getTime() + ms);
+		}
+		const d = new Date(spec.spec);
+		if (Number.isNaN(d.getTime())) {
+			return { error: `Invalid once schedule: ${spec.spec}` };
+		}
+		return d;
+	}
+	if (spec.kind === "interval") {
+		const ms = parseIntervalMs(spec.spec);
+		if (ms === undefined || ms <= 0) {
+			return { error: `Invalid interval: ${spec.spec}` };
+		}
+		return new Date(from.getTime() + ms);
+	}
+	if (spec.kind === "cron") {
+		const next = nextCronDate(spec.spec, from);
+		if (!next || !(next instanceof Date)) {
+			return (next as { error: string } | null) ?? { error: "Invalid cron expression" };
+		}
+		return next;
+	}
+	return { error: `Unknown schedule kind: ${(spec as unknown as Record<string, unknown>).kind}` };
+}
+
+export function humanizeSchedule(spec: ScheduleSpec): string {
+	if (spec.kind === "once") {
+		if (/^\+\d+(s|m|h|d)$/.test(spec.spec)) {
+			return `once in ${spec.spec.slice(1)}`;
+		}
+		return `once at ${spec.spec}`;
+	}
+	if (spec.kind === "interval") {
+		return `every ${spec.spec}`;
+	}
+	if (spec.kind === "cron") {
+		return `cron ${spec.spec}`;
+	}
+	return "unknown schedule";
+}