@tryaura/aura-cli 0.1.0 → 0.1.1

package/README.md

@@ -4,8 +4,9 @@ Composable CLI runtime for Aura distributions. The package exports `runCli` from
 official plugin composition from `@tryaura/aura-cli/plugins`. Installing it globally also provides
 the official `aura` command.
 
-The packages are prepared at `0.1.0` but are not published to npm yet. Until the first release,
-use the repository's `pnpm verify:packages` command to build and exercise local tarballs.
+```sh
+npm install -g @tryaura/aura-cli
+```
 
 See the [distro authoring guide](https://tryaura.sh/docs/guides/distributions) for branding, plugin
 composition, distribution defaults, bundled runtime presets, compiled binaries, and testkit usage.

package/dist/bin/aura.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { n as OFFICIAL_REGISTRY_OPTIONS, t as OFFICIAL_PLUGINS } from "../plugins-n3DS8XXi.js";
-import { t as runCli } from "../run-pMPxJqFQ.js";
+import { n as OFFICIAL_REGISTRY_OPTIONS, t as OFFICIAL_PLUGINS } from "../plugins-DDfc7XT9.js";
+import { t as runCli } from "../run-ZDkvqvZb.js";
 //#endregion
 //#region src/bin.ts
 await runCli({
@@ -8,7 +8,7 @@ await runCli({
 		command: "aura",
 		description: "Agent Unification & Repair Assistant",
 		displayName: "Aura",
-		version: "0.1.0"
+		version: "0.1.1"
 	},
 	plugins: OFFICIAL_PLUGINS,
 	registry: OFFICIAL_REGISTRY_OPTIONS

package/dist/index.js

@@ -1,4 +1,4 @@
-import { i as vetHttpUrl, n as clampHttpTimeout, r as failureReason, t as runCli } from "./run-pMPxJqFQ.js";
+import { i as vetHttpUrl, n as clampHttpTimeout, r as failureReason, t as runCli } from "./run-ZDkvqvZb.js";
 //#region ../core/src/http-post.ts
 /**
 * Creates a bounded, TLS-only JSON POST that never rejects.

package/dist/plugins/index.js

@@ -1,2 +1,2 @@
-import { a as codexPlugin, i as claudeCodePlugin, n as OFFICIAL_REGISTRY_OPTIONS, o as cursorPlugin, r as checksCorePlugin, s as officialContentPlugin, t as OFFICIAL_PLUGINS } from "../plugins-n3DS8XXi.js";
+import { a as codexPlugin, i as claudeCodePlugin, n as OFFICIAL_REGISTRY_OPTIONS, o as cursorPlugin, r as checksCorePlugin, s as officialContentPlugin, t as OFFICIAL_PLUGINS } from "../plugins-DDfc7XT9.js";
 export { OFFICIAL_PLUGINS, OFFICIAL_REGISTRY_OPTIONS, checksCorePlugin, claudeCodePlugin, codexPlugin, cursorPlugin, officialContentPlugin };

package/dist/{plugins-n3DS8XXi.js → plugins-DDfc7XT9.js}

@@ -1,4 +1,4 @@
-import { H as src_default$4, N as createAuraManifestWriteOperation, U as pluralize, V as SHARED_INSTRUCTIONS_TEMPLATE, _ as managedSnippetContentProblems, a as planSharedInstructionLink, b as canonicalizeManagedSnippet, c as planMcpSecretRemediation, f as planManifestMcpConvergence, i as skillDeploymentStatus, n as planSkillDeployment, o as canPlanMcpSecretRemediation, p as planMcpServerRemoval, r as sharedSkillsRoot, t as isAuraOwnedSkillTarget, u as mcpConvergenceBlockers, v as readManagedBlock, x as hashCanonicalManagedSnippet, y as AURA_MANAGED_SNIPPET_BEGIN_PREFIX } from "./skill-deployment-plan-C4GTrVSy.js";
+import { G as src_default$4, I as createAuraManifestWriteOperation, K as pluralize, S as readManagedBlock, W as SHARED_INSTRUCTIONS_TEMPLATE, _ as planSharedSkillTreeUpdate, b as reconcileManagedSnippet, c as planManifestMcpConvergence, f as isAuraOwnedSkillTarget, g as managedContentRevisionStatus, h as skillDeploymentStatus, i as planMcpSecretRemediation, l as planMcpServerRemoval, m as sharedSkillsRoot, n as canPlanMcpSecretRemediation, o as mcpConvergenceBlockers, p as planSkillDeployment, t as planSharedInstructionLink, v as reconcileParsedManagedBlock, y as diffManagedSnippet } from "./shared-link-plan-BigeLxDX.js";
 import { EMPTY_COLLECTION, McpWriteError, SHARED_INSTRUCTIONS_TEMPLATE_TOKEN, TIMEOUT_EXIT_CODE, collectJsonMcpServers, collectMcpServers, configStringArray, configStringRecord, defineAdapter, defineCheck, definePlugin, detectExecutable, detectLineEnding, inspectJsonMcpSecrets, isConfigRecord, isFileReference, jsonMcpEntry, jsonMcpSecretTransform, maskMarkdownCode, mcpCommandEntry, mcpEnvironmentVariableNames, mcpWriteResult, normalizeMcpServerDefinition, parseAtImports, parseConfigObject, parseInstalledSkills, parseJsonMcpConfig, redactMcpArguments, referenceTargetPath, sanitizeMcpUrl, skillDirectorySpecs, splitSourceLines, stdioTransport, writeJsonMcpServers } from "@tryaura/aura-sdk";
 import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { parse, stringify } from "smol-toml";
@@ -6,7 +6,6 @@ import { Buffer } from "node:buffer";
 import { parseTOML } from "toml-eslint-parser";
 import ignore from "ignore";
 import { createHash } from "node:crypto";
-import { createTwoFilesPatch } from "diff";
 import { isDeepStrictEqual } from "node:util";
 //#region ../../plugins/adapter-claude-code/src/contract.ts
 /**
@@ -4015,59 +4014,6 @@ function findingForProjectSignals(document, report, model) {
 	};
 }
 //#endregion
-//#region ../core/src/managed-block/reconcile-snippet.ts
-/** Reconciles exactly one snippet while preserving every other source byte. */
-function reconcileManagedSnippet(source, snippetId, resolution) {
-	const current = readManagedBlock(source);
-	if (current.status === "invalid") return invalidResult(source, current.notes, current.problems);
-	if (current.status === "absent") return missingSnippet(source, current.notes, snippetId, "an Aura-managed block");
-	const snippet = current.block.snippets.find((candidate) => candidate.id === snippetId);
-	if (snippet === void 0) return missingSnippet(source, current.notes, snippetId, "the Aura-managed block");
-	const lineEnding = markerLineEnding(source, snippet.startOffset, snippet.contentStartOffset);
-	const canonical = resolution.kind === "restore" ? canonicalizeManagedSnippet(resolution.content) : void 0;
-	if (canonical !== void 0) {
-		const problems = managedSnippetContentProblems(snippet.id, canonical);
-		if (problems.length > 0) return invalidResult(source, current.notes, problems);
-	}
-	const content = canonical === void 0 ? snippet.content : withLineEnding(canonical, lineEnding);
-	const hash = canonical === void 0 ? snippet.computedHash : hashCanonicalManagedSnippet(canonical);
-	const opening = `${AURA_MANAGED_SNIPPET_BEGIN_PREFIX}${snippet.id} sha256=${hash} -->${lineEnding}`;
-	const updated = source.slice(0, snippet.startOffset) + opening + content + source.slice(snippet.contentEndOffset);
-	return updated === source ? Object.freeze({
-		content: source,
-		notes: current.notes,
-		status: "unchanged"
-	}) : Object.freeze({
-		content: updated,
-		notes: current.notes,
-		status: "updated"
-	});
-}
-/** Creates the opt-in edited-versus-canonical detail used by the merge choice. */
-function diffManagedSnippet(path, editedContent, canonicalContent) {
-	return createTwoFilesPatch(`${path} (edited)`, `${path} (canonical)`, canonicalizeManagedSnippet(editedContent), canonicalizeManagedSnippet(canonicalContent), "edited", "canonical", { context: 3 });
-}
-function missingSnippet(source, notes, snippetId, location) {
-	return invalidResult(source, notes, [Object.freeze({
-		code: "missing-snippet",
-		message: `Snippet "${snippetId}" does not exist in ${location}.`
-	})]);
-}
-function invalidResult(source, notes, problems) {
-	return Object.freeze({
-		content: source,
-		notes,
-		problems,
-		status: "invalid"
-	});
-}
-function markerLineEnding(source, startOffset, contentStartOffset) {
-	return source.slice(startOffset, contentStartOffset).endsWith("\r\n") ? "\r\n" : "\n";
-}
-function withLineEnding(content, lineEnding) {
-	return lineEnding === "\n" ? content : content.replaceAll("\n", lineEnding);
-}
-//#endregion
 //#region ../../plugins/checks-core/src/instructions.ts
 const READY = "Aura can add the missing link with check --fix.";
 const sharedInstructionsCheck = defineCheck({
@@ -4323,9 +4269,9 @@ function isSymlinkDocument(document, model) {
 }
 //#endregion
 //#region ../../plugins/checks-core/src/mgd-001-fixes.ts
-const CHECK_ID$3 = "MGD-001";
+const CHECK_ID$5 = "MGD-001";
 function guidedFixes$2(finding, model) {
-	if (finding.checkId !== CHECK_ID$3) return [];
+	if (finding.checkId !== CHECK_ID$5) return [];
 	const kind = finding.metadata?.["kind"];
 	if (kind === "malformed") return [malformedMergeChoice(finding)];
 	if (kind === "unterminated-fence") return [unterminatedFenceChoice(finding)];
@@ -4576,6 +4522,297 @@ function manifestSnippetHashes(model) {
 	return hashes;
 }
 //#endregion
+//#region ../../plugins/checks-core/src/mgd-002-fixes.ts
+function managedContentUpdateChoices(finding, model) {
+	if (finding.checkId !== "MGD-002") return [];
+	const kind = finding.metadata?.["kind"];
+	if (kind === "snippet-update" || kind === "snippet-diverged") return snippetUpdateChoices(finding, model);
+	if (kind === "snippet-missing") return missingSnippetChoices(finding, model);
+	return kind === "skill-update" || kind === "skill-diverged" ? skillUpdateChoices(finding, model) : [];
+}
+/**
+* How a choice names the revision it would apply.
+*
+* A diverged revision is a deliberate move to content that is not newer, so calling it an update
+* would misdescribe what the user is accepting.
+*/
+function applyLabel(finding, version) {
+	return `${finding.metadata?.["kind"] === "snippet-update" || finding.metadata?.["kind"] === "skill-update" ? "Update to" : "Switch to"} ${version}`;
+}
+function snippetUpdateChoices(finding, model) {
+	const context = readyFindingContext(finding, model);
+	if (context === void 0) return [];
+	const { contentId, manifest: manifestState } = context;
+	const installed = manifestState.value.snippets.find((snippet) => snippet.id === contentId);
+	const available = model.availableSnippets.find((snippet) => snippet.id === contentId);
+	const located = locateManagedSnippet(model, contentId);
+	if (installed === void 0 || available === void 0 || located === void 0) return [];
+	if (!located.snippet.hashMatches || located.snippet.computedHash !== installed.hash) return [resolveDriftFirst(contentId)];
+	const reconciled = reconcileManagedSnippet(located.document.content, contentId, {
+		content: available.content,
+		kind: "restore"
+	});
+	if (reconciled.status === "invalid") return [resolveDriftFirst(contentId)];
+	const manifest = {
+		...manifestState.value,
+		snippets: manifestState.value.snippets.map((snippet) => snippet === installed ? {
+			...snippet,
+			hash: available.hash,
+			pinned: false,
+			version: available.version
+		} : snippet)
+	};
+	return [{
+		details: () => diffManagedSnippet(located.document.path, located.snippet.content, available.content),
+		id: "update",
+		label: applyLabel(finding, available.version),
+		plan: {
+			operations: [{
+				content: reconciled.content,
+				path: located.document.path,
+				type: "write"
+			}, createAuraManifestWriteOperation(manifestState, manifest)],
+			summary: `Set managed snippet ${contentId} to ${available.version}.`
+		}
+	}];
+}
+function missingSnippetChoices(finding, model) {
+	const context = readyFindingContext(finding, model);
+	if (context === void 0) return [];
+	const { contentId, manifest } = context;
+	const installed = manifest.value.snippets.find((snippet) => snippet.id === contentId);
+	if (installed === void 0) return [];
+	const pinnedManifest = {
+		...manifest.value,
+		snippets: manifest.value.snippets.map((snippet) => snippet === installed ? {
+			...snippet,
+			pinned: true
+		} : snippet)
+	};
+	const choices = [{
+		id: "pin",
+		label: "Keep as pinned",
+		plan: {
+			operations: [createAuraManifestWriteOperation(manifest, pinnedManifest)],
+			summary: `Keep unavailable snippet ${contentId} at its installed revision.`
+		}
+	}];
+	const removal = removeSnippetPlan(model, contentId, installed);
+	if (removal !== void 0) choices.push({
+		id: "remove",
+		label: "Remove",
+		plan: removal
+	});
+	return choices;
+}
+function removeSnippetPlan(model, contentId, installed) {
+	if (model.manifest.status !== "ready") return;
+	const located = locateManagedSnippet(model, contentId);
+	if (located === void 0) return;
+	const preserve = located.document.parsed.status === "present" ? located.document.parsed.block.snippets.map((snippet) => snippet.id).filter((id) => id !== contentId) : [];
+	const reconciled = reconcileParsedManagedBlock(located.document.content, located.document.parsed, [], {
+		ownedSnippetIds: model.manifest.value.snippets.map((snippet) => snippet.id),
+		preserveSnippetIds: preserve,
+		previousSnippetHashes: new Map(model.manifest.value.snippets.map((snippet) => [snippet.id, snippet.hash]))
+	});
+	if (reconciled.status === "invalid") return;
+	const manifest = {
+		...model.manifest.value,
+		snippets: model.manifest.value.snippets.filter((snippet) => snippet !== installed)
+	};
+	return {
+		operations: [{
+			content: reconciled.content,
+			path: located.document.path,
+			type: "write"
+		}, createAuraManifestWriteOperation(model.manifest, manifest)],
+		summary: `Remove unavailable managed snippet ${contentId}.`
+	};
+}
+function skillUpdateChoices(finding, model) {
+	const context = readyFindingContext(finding, model);
+	const sourceId = finding.metadata?.["sourceId"];
+	if (context === void 0 || typeof sourceId !== "string") return [];
+	const { contentId, manifest: manifestState } = context;
+	const installed = manifestState.value.skills.find((skill) => skill.id === contentId && skill.source === sourceId);
+	const available = model.availableSkills?.find((skill) => skill.id === contentId && skill.source.id === sourceId);
+	const shared = model.sharedSkills?.find((skill) => skill.id === contentId);
+	if (installed === void 0 || available === void 0 || shared === void 0) return [];
+	if (shared.problem !== void 0 || shared.treeHash !== installed.treeHash) return [resolveSkillDriftFirst(contentId)];
+	const manifest = {
+		...manifestState.value,
+		skills: manifestState.value.skills.map((skill) => skill === installed ? updatedSkill(skill, available) : skill)
+	};
+	return [{
+		id: "update",
+		label: applyLabel(finding, available.version),
+		plan: {
+			operations: [...planSharedSkillTreeUpdate(shared.path, shared.entries, available), createAuraManifestWriteOperation(manifestState, manifest)],
+			summary: `Set managed skill ${contentId} to ${available.version}.`
+		}
+	}];
+}
+function readyFindingContext(finding, model) {
+	const contentId = finding.metadata?.["contentId"];
+	return typeof contentId === "string" && model.manifest.status === "ready" ? {
+		contentId,
+		manifest: model.manifest
+	} : void 0;
+}
+function updatedSkill(installed, available) {
+	return {
+		...installed,
+		pinned: false,
+		treeHash: available.treeHash,
+		version: available.version
+	};
+}
+function locateManagedSnippet(model, contentId) {
+	for (const document of managedDocuments(model)) {
+		if (document.parsed.status !== "present") continue;
+		const snippet = document.parsed.block.snippets.find((candidate) => candidate.id === contentId);
+		if (snippet !== void 0) return {
+			document,
+			snippet
+		};
+	}
+}
+function resolveDriftFirst(contentId) {
+	return {
+		id: "resolve-drift",
+		label: "Resolve local edits first",
+		plan: {
+			manualSteps: [`Run \`aura check --only MGD-001 --fix --interactive\` and resolve edits to ${contentId}, then review this update again.`],
+			operations: [],
+			summary: `Resolve local edits to ${contentId} before updating it.`
+		}
+	};
+}
+function resolveSkillDriftFirst(contentId) {
+	return {
+		id: "resolve-drift",
+		label: "Review local edits first",
+		plan: {
+			manualSteps: [`Review the locally changed shared skill ${contentId}; pin or reconcile it before applying the source update.`],
+			operations: [],
+			summary: `Review local edits to skill ${contentId} before updating it.`
+		}
+	};
+}
+const managedContentUpdateCheck = defineCheck({
+	defaultSeverity: "info",
+	detect: detectManagedContentUpdates,
+	explain: "Aura records the exact version and content hash of each managed snippet and skill. When an installed plugin offers a different revision, Aura reports it and waits for a reviewed change instead of silently replacing managed content. A revision that is not newer — a rollback, or one this build cannot order — is reported too, because Aura keeps the recorded revision either way and an unreported hold would look like nothing to do. Pinned selections remain quiet until they are unpinned.\n\nRun `aura check --fix --interactive` to review bundled revisions and vanished snippets. Locally edited content must be resolved first; directory-sourced skill updates stay in `aura setup`, where network and credential approval are explicit.",
+	fix: () => void 0,
+	fixability: "guided",
+	guidedFixes: managedContentUpdateChoices,
+	id: "MGD-002",
+	scope: "global",
+	title: "Managed snippets and skills are at their reviewed source revisions"
+});
+function detectManagedContentUpdates(model) {
+	if (model.manifest.status !== "ready") return [];
+	return [...model.manifest.value.snippets.flatMap((snippet) => snippetFinding(snippet, model)), ...model.manifest.value.skills.flatMap((skill) => skillFinding(skill, model))];
+}
+function snippetFinding(installed, model) {
+	if (installed.pinned) return [];
+	const available = model.availableSnippets.find((snippet) => snippet.id === installed.id);
+	if (available === void 0) return [{
+		id: `snippet:${installed.id}:missing`,
+		message: `Managed snippet ${installed.id} at version ${installed.version} is no longer provided by an installed plugin.`,
+		metadata: {
+			contentId: installed.id,
+			kind: "snippet-missing"
+		}
+	}];
+	const status = managedContentRevisionStatus(installed.version, installed.hash, available.version, available.hash);
+	if (status === "current") return [];
+	if (status === "diverged") return [{
+		details: "Aura keeps the recorded revision because the offered one is not newer. Re-run `aura setup` interactively to switch to it deliberately, or pin this snippet to stop the comparison.",
+		id: `snippet:${installed.id}:diverged`,
+		message: `Managed snippet ${installed.id} is recorded at version ${installed.version}, but the installed plugin offers ${available.version}, which is not newer.`,
+		metadata: {
+			availableVersion: available.version,
+			contentId: installed.id,
+			installedVersion: installed.version,
+			kind: "snippet-diverged"
+		}
+	}];
+	return [{
+		id: `snippet:${installed.id}:update`,
+		message: `Managed snippet ${installed.id} can update from version ${installed.version} to ${available.version}.`,
+		metadata: {
+			availableVersion: available.version,
+			contentId: installed.id,
+			installedVersion: installed.version,
+			kind: "snippet-update"
+		}
+	}];
+}
+function skillFinding(installed, model) {
+	if (installed.pinned || !installed.source.startsWith("plugin:")) return [];
+	const available = model.availableSkills?.find((skill) => skill.id === installed.id && skill.source.id === installed.source);
+	if (available === void 0) return [];
+	const status = managedContentRevisionStatus(installed.version, installed.treeHash, available.version, available.treeHash);
+	if (status === "current") return [];
+	const location = { path: join(sharedSkillsRoot(model.homeDir), installed.id) };
+	if (status === "diverged") return [{
+		details: "Aura keeps the recorded revision because the offered one is not newer. Re-run `aura setup` interactively to switch to it deliberately, or pin this skill to stop the comparison.",
+		id: `skill:${installed.source}:${installed.id}:diverged`,
+		locations: [location],
+		message: `Managed skill ${installed.id} is recorded at version ${installed.version}, but the installed plugin offers ${available.version}, which is not newer.`,
+		metadata: {
+			availableVersion: available.version,
+			contentId: installed.id,
+			installedVersion: installed.version,
+			kind: "skill-diverged",
+			sourceId: installed.source
+		}
+	}];
+	return [{
+		id: `skill:${installed.source}:${installed.id}:update`,
+		locations: [location],
+		message: `Managed skill ${installed.id} can update from version ${installed.version} to ${available.version}.`,
+		metadata: {
+			availableVersion: available.version,
+			contentId: installed.id,
+			installedVersion: installed.version,
+			kind: "skill-update",
+			sourceId: installed.source
+		}
+	}];
+}
+/**
+* Deliberately manual: the only resolution is a full `setup` run.
+*
+* Recording the decision means asking the apps picker, and this check must never start a nested
+* command. Declaring it fixable would open an interactive fix on a single choice that changes
+* nothing — a prompt whose only answer leaves the finding exactly where it was — so the next step
+* is carried on the finding itself instead.
+*/
+const unmanagedDetectedAppCheck = defineCheck({
+	defaultSeverity: "info",
+	detect: detectUnmanagedApps,
+	explain: "Aura can inspect an installed agent application without managing it. This informational check highlights detected applications that have never been accepted or ignored in the Aura manifest.\n\nRun `aura setup` to add the application, or leave it unchecked once to record that Aura should ignore it. There is no automatic fix: the decision belongs to the apps step, and this check never starts a nested command.",
+	fixability: "manual",
+	id: "MGD-003",
+	scope: "global",
+	title: "Detected applications have an explicit Aura management decision"
+});
+function detectUnmanagedApps(model) {
+	const apps = model.manifest.status === "ready" ? model.manifest.value.apps : {};
+	const ignored = new Set(model.manifest.status === "ready" ? model.manifest.value.ignoredApps ?? [] : []);
+	return model.apps.flatMap((app) => {
+		if (app.synthetic === true || Object.hasOwn(apps, app.adapterId) || ignored.has(app.adapterId)) return [];
+		return [{
+			details: `Run \`aura setup\` and select ${app.displayName} to manage it, or leave it unchecked to record an ignored-app decision.`,
+			id: app.adapterId,
+			message: `${app.displayName} detected but not managed — run \`aura setup\` to add it.`,
+			metadata: { appId: app.adapterId }
+		}];
+	});
+}
+//#endregion
 //#region ../../plugins/checks-core/src/mcp-common.ts
 /**
 * The servers the manifest selects for applications this scan can actually converge.
@@ -4681,7 +4918,17 @@ function detectParity(model) {
 	if (model.manifest.status !== "ready") return [];
 	const desired = desiredMcpTargets(model);
 	const desiredByApp = /* @__PURE__ */ new Map();
-	const findings = [];
+	const findings = (model.overriddenRequiredMcpServers ?? []).map((override) => ({
+		details: "The omission was explicitly confirmed during setup and remains recorded in the Aura manifest. Run `aura setup` to add the server or keep the documented deviation.",
+		id: `override:${override.catalogId}`,
+		message: `MCP server ${override.catalogId} required by ${override.requiredBy} is explicitly omitted; this machine deviates from the team preset.`,
+		metadata: {
+			catalogId: override.catalogId,
+			kind: "preset-override",
+			requiredBy: override.requiredBy
+		},
+		severity: "info"
+	}));
 	const affected = /* @__PURE__ */ new Set();
 	for (const target of desired) {
 		const names = desiredByApp.get(target.appId) ?? /* @__PURE__ */ new Set();
@@ -5652,6 +5899,8 @@ const checksCorePlugin = definePlugin({
 		instructionContextBudgetCheck,
 		instructionPrecedenceCheck,
 		managedBlockHashCheck,
+		managedContentUpdateCheck,
+		unmanagedDetectedAppCheck,
 		mcp001,
 		mcp002,
 		mcp003,