@nairon-ai/aegis 0.6.2 → 0.7.0

package/src/cli/commands/pause.ts

@@ -0,0 +1,127 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { defineCommand } from "citty";
+import { consola } from "consola";
+import { resolvePackageBinary } from "../binaries.js";
+import { findPackageRoot, resolveEnvFileForWrite } from "../paths.js";
+
+export const pauseCommand = defineCommand({
+	meta: { name: "pause", description: "Pause Aegis so it cannot pick up new work" },
+	args: {
+		"local-only": {
+			type: "boolean",
+			description: "Only update .aegis/.env; do not update the deployed Worker",
+			default: false,
+		},
+	},
+	async run({ args }) {
+		await runPause({ localOnly: Boolean(args["local-only"]) });
+	},
+});
+
+export const resumeCommand = defineCommand({
+	meta: { name: "resume", description: "Resume Aegis after a pause" },
+	args: {
+		concurrency: {
+			type: "string",
+			description: "How many tickets Aegis may claim per pickup cycle",
+			default: "1",
+		},
+		"local-only": {
+			type: "boolean",
+			description: "Only update .aegis/.env; do not update the deployed Worker",
+			default: false,
+		},
+	},
+	async run({ args }) {
+		await runResume({
+			concurrency: parseConcurrency(String(args.concurrency ?? "1")),
+			localOnly: Boolean(args["local-only"]),
+		});
+	},
+});
+
+export async function runPause(options: { localOnly?: boolean } = {}): Promise<void> {
+	setLocalEnvValue("MAX_CONCURRENT_RUNS", "0");
+	consola.success("Saved local pause: MAX_CONCURRENT_RUNS=0");
+	if (!options.localOnly) {
+		pushWorkerSecret("MAX_CONCURRENT_RUNS", "0");
+	}
+
+	consola.success("Aegis is paused.");
+	consola.log("It will not claim tickets, move tickets, run stale recovery, or start sandboxes.");
+	consola.log("Resume with `aegis resume`.");
+}
+
+export async function runResume(
+	options: { concurrency?: number; localOnly?: boolean } = {},
+): Promise<void> {
+	const concurrency = options.concurrency ?? 1;
+	setLocalEnvValue("MAX_CONCURRENT_RUNS", String(concurrency));
+	consola.success(`Saved local resume: MAX_CONCURRENT_RUNS=${concurrency}`);
+	if (!options.localOnly) {
+		pushWorkerSecret("MAX_CONCURRENT_RUNS", String(concurrency));
+	}
+
+	consola.success("Aegis is resumed.");
+	consola.log(`Aegis may claim up to ${concurrency} ticket(s) per pickup cycle.`);
+}
+
+function pushWorkerSecret(key: string, value: string): void {
+	const packageRoot = findPackageRoot(import.meta.url);
+	const wranglerBin = resolvePackageBinary(packageRoot, "wrangler");
+	const wranglerConfig = resolve(packageRoot, "wrangler.jsonc");
+
+	consola.start(`Updating deployed Worker: ${key}=${value}`);
+	const result = spawnSync(wranglerBin, ["secret", "put", key, "--config", wranglerConfig], {
+		cwd: packageRoot,
+		input: value,
+		stdio: ["pipe", "pipe", "pipe"],
+		encoding: "utf-8",
+	});
+
+	if (result.status !== 0) {
+		throw new Error(
+			[
+				`Could not update the deployed Worker secret ${key}.`,
+				"Run `npx wrangler login`, then rerun this command.",
+				"Your local .aegis/.env was still updated.",
+				result.stderr || result.stdout,
+			]
+				.filter(Boolean)
+				.join("\n"),
+		);
+	}
+	consola.success("Deployed Worker updated. No Docker rebuild needed.");
+}
+
+function parseConcurrency(value: string): number {
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isFinite(parsed) || parsed < 1) {
+		throw new Error("Resume concurrency must be 1 or higher.");
+	}
+	return parsed;
+}
+
+function setLocalEnvValue(key: string, value: string): void {
+	const envFile = resolveEnvFileForWrite();
+	const lines = existsSync(envFile)
+		? readFileSync(envFile, "utf-8").replace(/\r/g, "").split("\n")
+		: ["# Aegis configuration. Do not commit this file."];
+	const nextLine = `${key}=${value}`;
+	let replaced = false;
+	const next = lines.map((line) => {
+		if (line.startsWith(`${key}=`)) {
+			replaced = true;
+			return nextLine;
+		}
+		return line;
+	});
+	if (!replaced) {
+		if (next.length && next[next.length - 1] !== "") next.push("");
+		next.push(nextLine);
+	}
+	mkdirSync(dirname(envFile), { recursive: true });
+	writeFileSync(envFile, `${next.join("\n").replace(/\n+$/, "")}\n`);
+}

package/src/cli/commands/status.ts

@@ -16,6 +16,8 @@ export async function runStatus(): Promise<void> {
 	printState(state);
 	if (state.config.monitoredRepo) consola.log(`  Repo: ${state.config.monitoredRepo}`);
 	if (state.config.workerUrl) consola.log(`  Worker: ${state.config.workerUrl}`);
+	const concurrency = state.config.maxConcurrentRuns ?? 1;
+	consola.log(`  Pickup: ${concurrency === 0 ? "paused" : `enabled (${concurrency} max/cycle)`}`);
 	const secretsSummary = formatGitHubSecretsSummary(
 		inspectGitHubActionsSecrets(state.config.monitoredRepo),
 	);

package/src/cli/index.ts

@@ -7,6 +7,7 @@ import { deployCommand } from "./commands/deploy.js";
 import { disconnectCommand } from "./commands/disconnect.js";
 import { initCommand } from "./commands/init.js";
 import { logsCommand } from "./commands/logs.js";
+import { pauseCommand, resumeCommand } from "./commands/pause.js";
 import { peekCommand } from "./commands/peek.js";
 import { pickupCommand } from "./commands/pickup.js";
 import { recoverCommand } from "./commands/recover.js";
@@ -30,6 +31,8 @@ const main = defineCommand({
 		peek: peekCommand,
 		logs: logsCommand,
 		recover: recoverCommand,
+		pause: pauseCommand,
+		resume: resumeCommand,
 		status: statusCommand,
 		deploy: deployCommand,
 		disconnect: disconnectCommand,

package/src/cli/state.ts

@@ -46,6 +46,9 @@ function loadConfigFileInto(config: AegisCliConfig, envFile: string): void {
 			case "CONTEXT_PROFILE":
 				config.contextProfile = value as AegisCliConfig["contextProfile"];
 				break;
+			case "MAX_CONCURRENT_RUNS":
+				config.maxConcurrentRuns = parseConfigInteger(value);
+				break;
 			case "READY_LABEL":
 				config.readyLabel = value;
 				break;
@@ -146,6 +149,7 @@ export function saveConfig(config: AegisCliConfig): void {
 	add("BASE_BRANCH", config.baseBranch);
 	add("AUTOMATION_MODE", config.automationMode);
 	add("CONTEXT_PROFILE", config.contextProfile);
+	add("MAX_CONCURRENT_RUNS", formatConfigInteger(config.maxConcurrentRuns));
 	add("READY_LABEL", config.readyLabel);
 	add("BUG_LABEL", config.bugLabel);
 	add("GITHUB_APP_ID", config.githubAppId);
@@ -208,6 +212,7 @@ export function printState(state: SetupState): void {
 	check(state.telegram, "Telegram approvals configured (optional)");
 	check(state.production, "Production context configured (optional)");
 	check(state.worker, "Worker URL saved");
+	check((state.config.maxConcurrentRuns ?? 1) > 0, "Aegis pickup enabled");
 	consola.log("");
 }
 
@@ -225,6 +230,14 @@ export async function runInteractiveMenu(): Promise<void> {
 		const { runRecover } = await import("./commands/recover.js");
 		await runRecover({ olderThanMinutes: 20 });
 	}
+	if (choice === "pause") {
+		const { runPause } = await import("./commands/pause.js");
+		await runPause();
+	}
+	if (choice === "resume") {
+		const { runResume } = await import("./commands/pause.js");
+		await runResume({ concurrency: 1 });
+	}
 	if (choice === "setup") {
 		const { runSetupWizard } = await import("./commands/setup.js");
 		await runSetupWizard();
@@ -252,6 +265,8 @@ async function promptMenuChoice(): Promise<string | undefined> {
 				{ label: "Find ready bugs (dry run)", value: "pickup" },
 				{ label: "View active runs", value: "runs" },
 				{ label: "Recover stale runs", value: "recover" },
+				{ label: "Pause Aegis", value: "pause" },
+				{ label: "Resume Aegis", value: "resume" },
 				{ label: "Run setup", value: "setup" },
 				{ label: "View status", value: "status" },
 				{ label: "Deploy worker", value: "deploy" },
@@ -267,3 +282,12 @@ async function promptMenuChoice(): Promise<string | undefined> {
 		throw error;
 	}
 }
+
+function parseConfigInteger(value: string): number | undefined {
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function formatConfigInteger(value: number | undefined): string | undefined {
+	return typeof value === "number" ? String(value) : undefined;
+}

package/src/core/runs.ts

@@ -1,9 +1,8 @@
+import { blockRunWithNotification } from "../agent/client.js";
 import { GitHubClient } from "../integrations/github.js";
 import { LinearClient } from "../integrations/linear.js";
-import { sendTelegramMessage } from "../integrations/telegram.js";
 import { runFromItem } from "../shared/run-state.js";
 import type { AegisConfig, RunSnapshot, WorkItem, WorkItemStatus } from "../shared/types.js";
-import { sourceFor } from "../sources/index.js";
 
 const ACTIVE_STATUSES: WorkItemStatus[] = ["claimed", "planning", "implementing"];
 const TRACKED_STATUSES: WorkItemStatus[] = [
@@ -70,11 +69,13 @@ export async function recoverStaleRuns(
 		}
 
 		const message = staleRunMessage(snapshot.run.id, options.olderThanMinutes);
-		await sourceFor(config, snapshot.item.source).markBlocked(snapshot.item, message);
-		await sendTelegramMessage(
+		await blockRunWithNotification({
 			config,
-			`Aegis stopped ${snapshot.item.identifier}: it did not finish an RCA within ${options.olderThanMinutes} minutes.\n\nRun: ${snapshot.run.id}\nTicket: ${snapshot.item.url}`,
-		);
+			item: snapshot.item,
+			run: snapshot.run,
+			trackerMessage: message,
+			telegramMessage: `Aegis stopped ${snapshot.item.identifier}: it did not finish an RCA within ${options.olderThanMinutes} minutes.\n\nRun: ${snapshot.run.id}\nTicket: ${snapshot.item.url}`,
+		});
 		results.push({
 			runId: snapshot.run.id,
 			identifier: snapshot.item.identifier,

package/src/server/app.ts

@@ -1,15 +1,11 @@
 import { Hono } from "hono";
-import { startImplementationRun, startPlanRun } from "../agent/client.js";
+import { blockRunWithNotification, startImplementationRun, startPlanRun } from "../agent/client.js";
 import type { BugFixAgentCaller } from "../agent/client.js";
 import { pickupReadyBugs, scanReadyBugs } from "../core/pickup.js";
 import { listRunSnapshots, recoverStaleRuns } from "../core/runs.js";
 import { GitHubClient } from "../integrations/github.js";
 import { LinearClient } from "../integrations/linear.js";
-import {
-	parseAegisCommand,
-	parseTelegramUpdate,
-	sendTelegramMessage,
-} from "../integrations/telegram.js";
+import { parseAegisCommand, parseTelegramUpdate } from "../integrations/telegram.js";
 import { verifyGitHubWebhook, verifyLinearWebhook } from "../integrations/webhooks.js";
 import { configFromBindings } from "../shared/config.js";
 import { formatReadyDecisionLine } from "../shared/format.js";
@@ -21,7 +17,6 @@ import type {
 	WorkItem,
 	WorkRun,
 } from "../shared/types.js";
-import { sourceFor } from "../sources/index.js";
 
 type HonoBindings = { Bindings: Bindings };
 type AegisAppOptions = {
@@ -39,6 +34,16 @@ export function createAegisApp(options: AegisAppOptions = {}) {
 		return c.json({ service: "aegis", status: "ok", product: "AFK bug-fixing agent" });
 	});
 
+	app.get("/api/status", (c) => {
+		const config = { ...configFromBindings(c.env), workerUrl: new URL(c.req.url).origin };
+		return c.json({
+			service: "aegis",
+			paused: isPaused(config),
+			maxConcurrentRuns: config.maxConcurrentRuns,
+			repo: config.monitoredRepo,
+		});
+	});
+
 	app.get("/api/pickup", async (c) => {
 		const config = { ...configFromBindings(c.env), workerUrl: new URL(c.req.url).origin };
 		const decisions = await scanReadyBugs(config);
@@ -59,6 +64,14 @@ export function createAegisApp(options: AegisAppOptions = {}) {
 
 	app.post("/api/pickup", async (c) => {
 		const config = { ...configFromBindings(c.env), workerUrl: new URL(c.req.url).origin };
+		if (isPaused(config)) {
+			return c.json({
+				paused: true,
+				count: 0,
+				decisions: [],
+				message: "Aegis is paused. Run `aegis resume` to allow pickup again.",
+			});
+		}
 		const recovered = await recoverStaleRuns(config, {
 			olderThanMinutes: staleRunMinutes(c.env),
 		});
@@ -101,6 +114,13 @@ export function createAegisApp(options: AegisAppOptions = {}) {
 
 	app.post("/api/runs/recover", async (c) => {
 		const config = { ...configFromBindings(c.env), workerUrl: new URL(c.req.url).origin };
+		if (isPaused(config)) {
+			return c.json({
+				paused: true,
+				results: [],
+				message: "Aegis is paused. Stale-run recovery is disabled.",
+			});
+		}
 		const results = await recoverStaleRuns(config, {
 			olderThanMinutes: staleRunMinutes(c.env),
 		});
@@ -131,7 +151,6 @@ export function createAegisApp(options: AegisAppOptions = {}) {
 		}
 		if (command.action === "stop") {
 			await stopRun(c.env, command.runId);
-			await sendTelegramMessage(config, `Stopped Aegis run ${command.runId}.`);
 			return c.json({ accepted: true });
 		}
 		await askRun(
@@ -164,6 +183,7 @@ export function createAegisApp(options: AegisAppOptions = {}) {
 			event === "issues" &&
 			["opened", "edited", "labeled", "unlabeled", "reopened"].includes(payload.action ?? "")
 		) {
+			if (isPaused(config)) return c.json({ accepted: true, paused: true });
 			c.executionCtx.waitUntil(
 				pickupFromWebhook(c.env, new URL(c.req.url).origin, options.callBugFixAgent),
 			);
@@ -207,6 +227,7 @@ export function createAegisApp(options: AegisAppOptions = {}) {
 		}
 		if (payload.type !== "Comment") {
 			if (payload.type === "Issue") {
+				if (isPaused(config)) return c.json({ accepted: true, paused: true });
 				c.executionCtx.waitUntil(
 					pickupFromWebhook(c.env, new URL(c.req.url).origin, options.callBugFixAgent),
 				);
@@ -235,6 +256,10 @@ export async function scheduledPickup(
 	callAgent?: BugFixAgentCaller,
 ): Promise<void> {
 	const config = configFromBindings(env);
+	if (isPaused(config)) {
+		console.log("[aegis] scheduled pickup skipped because Aegis is paused");
+		return;
+	}
 	const recovered = await recoverStaleRuns(config, { olderThanMinutes: staleRunMinutes(env) });
 	const blocked = recovered.filter((result) => result.status === "blocked");
 	if (blocked.length) {
@@ -304,11 +329,13 @@ async function startPlanSafely(
 				: error instanceof Error
 					? error.message
 					: String(error);
-		await sourceFor(config, item.source).markBlocked(item, `Aegis failed to run: ${message}`);
-		await sendTelegramMessage(
+		await blockRunWithNotification({
 			config,
-			`Aegis stopped ${item.identifier}: ${message}\n\nRun: ${run.id}\nTicket: ${item.url}`,
-		);
+			item,
+			run,
+			trackerMessage: `Aegis failed to run: ${message}`,
+			telegramMessage: `Aegis stopped ${item.identifier}: ${message}\n\nRun: ${run.id}\nTicket: ${item.url}`,
+		});
 	}
 }
 
@@ -322,6 +349,7 @@ async function pickupFromWebhook(
 		...configFromBindings(env),
 		workerUrl: configFromBindings(env).workerUrl ?? origin,
 	};
+	if (isPaused(config)) return;
 	await pickupReadyBugs({
 		config,
 		startRun: async (item, run, decision) => {
@@ -341,15 +369,26 @@ async function proceedRun(
 	const config = configFromBindings(env);
 	const resolved = item ?? (await resolveItemFromRunId(config, runId));
 	const run = runFromItem(resolved, "plan-first");
-	await startImplementationRun({
-		config,
-		item: resolved,
-		run,
-		approvedBy: actor,
-		callAgent,
-		env,
-		ctx,
-	});
+	try {
+		await startImplementationRun({
+			config,
+			item: resolved,
+			run,
+			approvedBy: actor,
+			callAgent,
+			env,
+			ctx,
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		await blockRunWithNotification({
+			config,
+			item: resolved,
+			run,
+			trackerMessage: `Aegis failed during implementation: ${message}`,
+			telegramMessage: `Aegis failed during implementation for ${resolved.identifier}.\n\nReason: ${message}\n\nRun: ${run.id}\nTicket: ${resolved.url}`,
+		});
+	}
 }
 
 async function askRun(
@@ -371,21 +410,44 @@ async function askRun(
 Human follow-up from ${actor}:
 ${text}`,
 	};
-	await startPlanRun({
-		config,
-		item: followUpItem,
-		run: runFromItem(resolved, "plan-first"),
-		decision: { ready: true, reason: "human follow-up", risk: "low", autoImplementAllowed: false },
-		callAgent,
-		env,
-		ctx,
-	});
+	const run = runFromItem(resolved, "plan-first");
+	try {
+		await startPlanRun({
+			config,
+			item: followUpItem,
+			run,
+			decision: {
+				ready: true,
+				reason: "human follow-up",
+				risk: "low",
+				autoImplementAllowed: false,
+			},
+			callAgent,
+			env,
+			ctx,
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		await blockRunWithNotification({
+			config,
+			item: resolved,
+			run,
+			trackerMessage: `Aegis failed while handling follow-up context: ${message}`,
+			telegramMessage: `Aegis failed while handling follow-up context for ${resolved.identifier}.\n\nReason: ${message}\n\nRun: ${run.id}\nTicket: ${resolved.url}`,
+		});
+	}
 }
 
 async function stopRun(env: Bindings, runId: string, item?: WorkItem): Promise<void> {
 	const config = configFromBindings(env);
 	const resolved = item ?? (await resolveItemFromRunId(config, runId));
-	await sourceFor(config, resolved.source).markBlocked(resolved, `Aegis run ${runId} was stopped.`);
+	await blockRunWithNotification({
+		config,
+		item: resolved,
+		run: { id: runId },
+		trackerMessage: `Aegis run ${runId} was stopped.`,
+		telegramMessage: `Aegis run ${runId} was stopped.\n\nTicket: ${resolved.url}`,
+	});
 }
 
 async function withTimeout<T>(
@@ -425,6 +487,10 @@ function parsePositiveInteger(value: string | undefined, fallback: number): numb
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
+function isPaused(config: { maxConcurrentRuns: number }): boolean {
+	return config.maxConcurrentRuns <= 0;
+}
+
 async function resolveItemFromRunId(
 	config: ReturnType<typeof configFromBindings>,
 	runId: string,

package/src/shared/config.ts

@@ -77,6 +77,7 @@ export function configFromCli(cli: AegisCliConfig): AegisConfig {
 		baseBranch: cli.baseBranch,
 		automationMode: cli.automationMode,
 		contextProfile: cli.contextProfile,
+		maxConcurrentRuns: cli.maxConcurrentRuns,
 		readyLabel: cli.readyLabel,
 		bugLabel: cli.bugLabel,
 		github: {

package/src/shared/types.ts

@@ -269,6 +269,7 @@ export type AegisCliConfig = {
 	baseBranch?: string;
 	automationMode?: AutomationMode;
 	contextProfile?: ContextProfile;
+	maxConcurrentRuns?: number;
 	readyLabel?: string;
 	bugLabel?: string;
 	githubAppId?: string;