@f5xc-salesdemos/xcsh 19.42.2 → 19.43.1

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5xc-salesdemos/xcsh",
-	"version": "19.42.2",
+	"version": "19.43.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5xc-salesdemos/xcsh",
 	"author": "Can Boluk",
@@ -52,13 +52,13 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.16.1",
 		"@mozilla/readability": "^0.6",
-		"@f5xc-salesdemos/xcsh-stats": "19.42.2",
-		"@f5xc-salesdemos/pi-agent-core": "19.42.2",
-		"@f5xc-salesdemos/pi-ai": "19.42.2",
-		"@f5xc-salesdemos/pi-natives": "19.42.2",
-		"@f5xc-salesdemos/pi-resource-management": "19.42.2",
-		"@f5xc-salesdemos/pi-tui": "19.42.2",
-		"@f5xc-salesdemos/pi-utils": "19.42.2",
+		"@f5xc-salesdemos/xcsh-stats": "19.43.1",
+		"@f5xc-salesdemos/pi-agent-core": "19.43.1",
+		"@f5xc-salesdemos/pi-ai": "19.43.1",
+		"@f5xc-salesdemos/pi-natives": "19.43.1",
+		"@f5xc-salesdemos/pi-resource-management": "19.43.1",
+		"@f5xc-salesdemos/pi-tui": "19.43.1",
+		"@f5xc-salesdemos/pi-utils": "19.43.1",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.20",

package/src/cli/chrome-cli.ts

@@ -15,14 +15,8 @@ type Settings = { get(key: string): unknown };
 
 export type ChromeAction = "status" | "relaunch" | "setup";
 
-// Unpacked (keyed) build — installed from a GitHub release. The manifest `key`
-// pins this deterministic ID.
-export const EXTENSION_ID = "khlalklompggpfnmeclpligmcbknkemg";
-// Chrome Web Store build — the store assigns this ID (no `key` field).
-export const EXTENSION_ID_CWS = "klajkjdoehjidngligegnpknogmjjhkc";
-// Both are allowed in the native-host manifest so the bridge works regardless of
-// how the user installed the extension.
-export const EXTENSION_IDS = [EXTENSION_ID, EXTENSION_ID_CWS];
+export const EXTENSION_ID = "klajkjdoehjidngligegnpknogmjjhkc";
+export const EXTENSION_IDS = [EXTENSION_ID];
 
 const NATIVE_HOST_NAME = "com.f5xc.xcsh.chrome_host";
 

package/src/internal-urls/build-info.generated.ts

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "19.42.2",
-	"commit": "a018af25c2adec4357b1aa63213417ef9331ef18",
-	"shortCommit": "a018af2",
+	"version": "19.43.1",
+	"commit": "5b36c788a2d9ad0fb4a7da83458621d0e995a05a",
+	"shortCommit": "5b36c78",
 	"branch": "main",
-	"tag": "v19.42.2",
-	"commitDate": "2026-06-24T03:15:55Z",
-	"buildDate": "2026-06-24T03:45:49.205Z",
+	"tag": "v19.43.1",
+	"commitDate": "2026-06-24T15:09:09Z",
+	"buildDate": "2026-06-24T15:34:16.139Z",
 	"dirty": true,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5xc-salesdemos/xcsh",
 	"repoSlug": "f5xc-salesdemos/xcsh",
-	"commitUrl": "https://github.com/f5xc-salesdemos/xcsh/commit/a018af25c2adec4357b1aa63213417ef9331ef18",
-	"releaseUrl": "https://github.com/f5xc-salesdemos/xcsh/releases/tag/v19.42.2"
+	"commitUrl": "https://github.com/f5xc-salesdemos/xcsh/commit/5b36c788a2d9ad0fb4a7da83458621d0e995a05a",
+	"releaseUrl": "https://github.com/f5xc-salesdemos/xcsh/releases/tag/v19.43.1"
 };

package/src/main.ts

@@ -621,7 +621,7 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		const { ContextService } = await import("./services/f5xc-context");
 		const { getF5XCConfigDir } = await import("@f5xc-salesdemos/pi-utils");
 		const contextService = ContextService.init(getF5XCConfigDir());
-		await contextService.loadActive();
+		await contextService.loadActive(cwd);
 	} catch {
 		// F5 XC auth is optional — silently continue if anything fails
 	}

package/src/modes/theme/theme.ts

@@ -10,13 +10,15 @@ import {
 	supportsLanguage as nativeSupportsLanguage,
 } from "@f5xc-salesdemos/pi-natives";
 import type { EditorTheme, MarkdownTheme, SelectListTheme, SymbolTheme } from "@f5xc-salesdemos/pi-tui";
-import { adjustHsv, getCustomThemesDir, isEnoent, logger } from "@f5xc-salesdemos/pi-utils";
+import { adjustHsv, detectDiagramType, getCustomThemesDir, isEnoent, logger } from "@f5xc-salesdemos/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
 import chalk from "chalk";
+import { buildMermaidBlockOptions, diagramTypeLabel } from "../../tools/mermaid-renderer";
+import { renderOutputBlock } from "../../tui";
 // Embed theme JSON files at build time
 import { defaultThemes } from "./defaults";
-import { getMermaidAscii, mermaidThemeSignature } from "./mermaid-cache";
+import { getMermaidAscii, mermaidThemeSignature, renderMermaidThemed } from "./mermaid-cache";
 
 export { getLanguageFromPath } from "../../utils/lang-from-path";
 
@@ -2510,6 +2512,14 @@ export function getMarkdownTheme(): MarkdownTheme {
 		strikethrough: (text: string) => chalk.strikethrough(text),
 		symbols: getSymbolTheme(),
 		getMermaidAscii: (hash: bigint | number) => getMermaidAscii(hash, mermaidThemeSignature(theme)),
+		renderMermaidBlock: (source: string, width: number): string[] | null => {
+			const diagram = renderMermaidThemed(source, theme);
+			if (!diagram) return null;
+			return renderOutputBlock(
+				buildMermaidBlockOptions(diagram, { width, theme, typeLabel: diagramTypeLabel(detectDiagramType(source)) }),
+				theme,
+			);
+		},
 		highlightCode: (code: string, lang?: string): string[] => {
 			const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
 			try {

package/src/services/f5xc-context-command.ts

@@ -1,5 +1,13 @@
 import * as fs from "node:fs";
-import { t } from "@f5xc-salesdemos/pi-utils";
+import * as path from "node:path";
+import {
+	getLocalF5XCActiveContextPath,
+	getLocalF5XCContextPath,
+	getLocalF5XCContextsDir,
+	getProjectDir,
+	isSafeContextName,
+	t,
+} from "@f5xc-salesdemos/pi-utils";
 import { SECRET_ENV_PATTERNS } from "../secrets/index";
 import { expandTilde } from "../tools/path-utils";
 import { ContextError, ContextService, CURRENT_SCHEMA_VERSION } from "./f5xc-context";
@@ -39,7 +47,7 @@ export async function handleContextCommand(
 ): Promise<void> {
 	const [sub, ...rest] = command.args.trim().split(/\s+/);
 	const arg = rest.join(" ");
-	const service = await ContextService.getOrInit();
+	const service = await ContextService.getOrInit(undefined, getProjectDir());
 
 	ctx.editor.setText("");
 
@@ -75,6 +83,10 @@ export async function handleContextCommand(
 		}
 		case "namespace":
 			return handleNamespace(ctx, service, arg);
+		case "link":
+			return handleLink(ctx, service, arg);
+		case "unlink":
+			return handleUnlink(ctx, service);
 		case "env":
 			return handleEnvSubcommand(ctx, service, rest);
 		case "set":
@@ -102,6 +114,17 @@ function sanitize(value: string): string {
 	return value.replace(/[\x00-\x1f\x7f]/g, "");
 }
 
+/**
+ * Atomic file write: write to a .tmp file then rename.
+ * Ensures 0o600 permissions on the resulting file.
+ */
+function atomicWriteLocal(filePath: string, content: string): void {
+	const tmpPath = `${filePath}.tmp`;
+	fs.writeFileSync(tmpPath, content, { mode: 0o600 });
+	fs.renameSync(tmpPath, filePath);
+	fs.chmodSync(filePath, 0o600);
+}
+
 /**
  * Split a positional+flag argument list into two groups.
  *
@@ -129,6 +152,58 @@ function splitArgs(args: string[], knownFlags: Set<string>): { positionals: stri
 }
 
 async function handleList(ctx: CommandContext, service: ContextService): Promise<void> {
+	const localContextsDir = getLocalF5XCContextsDir(getProjectDir());
+	const hasLocalDir = fs.existsSync(localContextsDir);
+
+	if (hasLocalDir) {
+		// Build local context rows by reading .xcsh/contexts/*.json directly
+		const localRows: TableRow[] = [];
+		try {
+			const files = fs.readdirSync(localContextsDir).filter(f => f.endsWith(".json"));
+			for (const file of files.sort()) {
+				const name = file.slice(0, -5); // strip .json
+				try {
+					const raw = fs.readFileSync(path.join(localContextsDir, file), "utf-8");
+					const parsed = JSON.parse(raw) as Record<string, unknown>;
+					const displayUrl =
+						typeof parsed.context === "string"
+							? `→ ${sanitize(parsed.context)} (pointer)`
+							: sanitize(typeof parsed.apiUrl === "string" ? parsed.apiUrl : "");
+					localRows.push({ key: `  ${sanitize(name)}`, value: displayUrl });
+				} catch {
+					localRows.push({ key: `  ${sanitize(name)}`, value: "(unreadable)" });
+				}
+			}
+		} catch {
+			// skip unreadable dir
+		}
+
+		// Build global context rows
+		const globalContexts = await service.listContexts();
+		const status = service.getStatus();
+		const globalRows: TableRow[] = globalContexts.map(p => {
+			const isActive = p.name === status.activeContextName;
+			const marker = isActive ? `${formatStatusIcon("connected")} ` : "  ";
+			const versionSuffix =
+				p.version !== undefined && p.version > CURRENT_SCHEMA_VERSION ? ` (v${p.version} — upgrade required)` : "";
+			return { key: `${marker}${sanitize(p.name)}`, value: `${sanitize(p.apiUrl)}${versionSuffix}` };
+		});
+
+		// Render combined table with group dividers
+		const rows: TableRow[] = [];
+		const dividers: Array<{ before: number; label: string }> = [];
+
+		dividers.push({ before: 0, label: "Local contexts (.xcsh/contexts/)" });
+		rows.push(...(localRows.length > 0 ? localRows : [{ key: "  (none)", value: "" }]));
+
+		dividers.push({ before: rows.length, label: "Global contexts (~/.config/f5xc/contexts/)" });
+		rows.push(...(globalRows.length > 0 ? globalRows : [{ key: "  (none)", value: "" }]));
+
+		ctx.showStatus(renderF5XCTable("contexts", rows, { dividers }), { dim: false });
+		return;
+	}
+
+	// No local dir — use original flat list behavior
 	const contexts = await service.listContexts();
 	if (contexts.length === 0) {
 		const status = service.getStatus();
@@ -157,6 +232,56 @@ async function handleList(ctx: CommandContext, service: ContextService): Promise
 	ctx.showStatus(renderF5XCTable("contexts", rows), { dim: false });
 }
 
+async function handleLink(ctx: CommandContext, service: ContextService, name: string): Promise<void> {
+	if (!name) {
+		ctx.showError("Usage: /context link <global-context-name>");
+		return;
+	}
+	if (!isSafeContextName(name)) {
+		ctx.showError(
+			"Invalid context name. Names must be 1-64 characters using only letters, digits, hyphens, or underscores.",
+		);
+		return;
+	}
+	const contexts = await service.listContexts();
+	const exists = contexts.some(c => c.name === name);
+	if (!exists) {
+		ctx.showError(`Global context '${name}' not found. Run /context list to see available contexts.`);
+		return;
+	}
+	const localContextsDir = getLocalF5XCContextsDir(getProjectDir());
+	if (!fs.existsSync(localContextsDir)) {
+		fs.mkdirSync(localContextsDir, { recursive: true, mode: 0o700 });
+	}
+	const pointerPath = getLocalF5XCContextPath(name, getProjectDir());
+	atomicWriteLocal(pointerPath, JSON.stringify({ context: name }, null, 2));
+	const activeContextPath = getLocalF5XCActiveContextPath(getProjectDir());
+	atomicWriteLocal(activeContextPath, name);
+	ctx.showStatus(renderContextMessage(name, `Linked local context '${name}' → global context '${name}'.`), {
+		dim: false,
+	});
+}
+
+async function handleUnlink(ctx: CommandContext, _service: ContextService): Promise<void> {
+	const activeContextPath = getLocalF5XCActiveContextPath(getProjectDir());
+	if (!fs.existsSync(activeContextPath)) {
+		ctx.showError("No local active context found. Run /context link <name> to create one.");
+		return;
+	}
+	const name = fs.readFileSync(activeContextPath, "utf-8").trim();
+	if (!isSafeContextName(name)) {
+		ctx.showError("Corrupt active_context file — invalid context name. Removing the file.");
+		fs.unlinkSync(activeContextPath);
+		return;
+	}
+	const pointerPath = getLocalF5XCContextPath(name, getProjectDir());
+	if (fs.existsSync(pointerPath)) {
+		fs.unlinkSync(pointerPath);
+	}
+	fs.unlinkSync(activeContextPath);
+	ctx.showStatus(renderContextMessage(name, `Unlinked local context '${name}'.`), { dim: false });
+}
+
 async function handleActivate(ctx: CommandContext, service: ContextService, name: string): Promise<void> {
 	if (!name) {
 		ctx.showError(t("context.activate.usage"));

package/src/services/f5xc-context.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getF5XCConfigDir, logger } from "@f5xc-salesdemos/pi-utils";
+import { ContextResolver, getF5XCConfigDir, logger } from "@f5xc-salesdemos/pi-utils";
 import { Settings } from "../config/settings";
 import { SECRET_ENV_PATTERNS } from "../secrets/index";
 import { F5XCApiClient } from "./f5xc-api-client";
@@ -303,12 +303,14 @@ export class ContextService {
 	 *
 	 * @param configDir — seed directory when bootstrapping; ignored when an
 	 *   instance already exists.
+	 * @param cwd — working directory for local context resolution; passed to
+	 *   loadActive(). Ignored when an instance already exists.
 	 */
-	static async getOrInit(configDir?: string): Promise<ContextService> {
+	static async getOrInit(configDir?: string, cwd?: string): Promise<ContextService> {
 		if (ContextService.#instance) return ContextService.#instance;
 		const dir = configDir ?? getF5XCConfigDir();
 		const service = ContextService.init(dir);
-		await service.loadActive();
+		await service.loadActive(cwd);
 		return service;
 	}
 
@@ -375,7 +377,7 @@ export class ContextService {
 		return this.#activeContext?.defaultNamespace ?? null;
 	}
 
-	async loadActive(): Promise<F5XCContext | null> {
+	async loadActive(cwd?: string): Promise<F5XCContext | null> {
 		// FR-102: F5XC_API_URL is the signal to skip context loading entirely.
 		// Subprocesses inherit process.env, so they already see the env vars directly.
 		if (process.env[F5XC_API_URL]) {
@@ -383,6 +385,50 @@ export class ContextService {
 			return null;
 		}
 
+		// FR-201: Check for project-local context in .xcsh/contexts/
+		if (cwd) {
+			const resolver = new ContextResolver();
+			const localResult = await resolver.resolve(cwd);
+			if (localResult && localResult.source === "local") {
+				const localContext = localResult.context as F5XCContext;
+				// Gate: incompatible schema version
+				let versionOk = true;
+				try {
+					this.#assertCompatibleVersion(localContext);
+				} catch (err) {
+					versionOk = false;
+					logger.warn("F5XC: local context uses incompatible schema version, skipping", {
+						sourcePath: localResult.sourcePath,
+						error: String(err),
+					});
+					// Fall through to global resolution below
+				}
+				if (versionOk) {
+					this.#activeContext = localContext;
+					this.#applyToSettings(localContext);
+					this.#credentialSource = hasEnvOverride() ? "mixed" : "context";
+					this.#refreshApiClient(localContext);
+					logger.debug("F5XC: using project context", {
+						name: localContext.name,
+						source: localResult.sourcePath,
+					});
+					// Run git-tracking safety check asynchronously
+					resolver
+						.checkGitTracking(localResult.sourcePath)
+						.then(tracked => {
+							if (tracked) {
+								logger.warn(
+									`WARNING: ${localResult.sourcePath} is tracked by git! ` +
+										`This file may contain credentials. Run: git rm --cached ${localResult.sourcePath}`,
+								);
+							}
+						})
+						.catch(() => {});
+					return localContext;
+				}
+			}
+		}
+
 		// Check if config dir exists
 		if (!fs.existsSync(this.#configDir)) {
 			return null;

package/src/tools/mermaid-renderer.ts

@@ -1,18 +1,18 @@
-/** TUI renderer for the render_mermaid tool — bordered, themed, colorized diagram output. */
+/** TUI renderer for the render_mermaid tool — single F5-framed, themed, colorized diagram. */
 import type { Component } from "@f5xc-salesdemos/pi-tui";
-import { Text } from "@f5xc-salesdemos/pi-tui";
+import { Text, visibleWidth } from "@f5xc-salesdemos/pi-tui";
 import { detectDiagramType, type MermaidDiagramType } from "@f5xc-salesdemos/pi-utils";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { renderMermaidThemed } from "../modes/theme/mermaid-cache";
 import type { Theme } from "../modes/theme/theme";
-import { CachedOutputBlock, F5_TOOL_BORDER_COLOR, renderStatusLine } from "../tui";
+import { CachedOutputBlock, F5_TOOL_BORDER_COLOR, type OutputBlockOptions, renderStatusLine } from "../tui";
 import type { RenderMermaidToolDetails } from "./render-mermaid";
-import { addSection, formatErrorMessage, replaceTabs } from "./render-utils";
+import { formatErrorMessage, replaceTabs } from "./render-utils";
 
 const TOOL_TITLE = "Mermaid";
 
-/** Human-friendly caption for the diagram-type badge in the block header. */
-function diagramTypeLabel(type: MermaidDiagramType): string {
+/** Human-friendly caption for the diagram type, shown in the F5 frame header. */
+export function diagramTypeLabel(type: MermaidDiagramType): string {
 	switch (type) {
 		case "flowchart":
 			return "flowchart";
@@ -31,6 +31,41 @@ function diagramTypeLabel(type: MermaidDiagramType): string {
 	}
 }
 
+/**
+ * Build the F5 output-block options that frame a themed/colored mermaid diagram.
+ * Shared by the render_mermaid tool result AND inline ```mermaid markdown blocks, so
+ * every mermaid render gets the SAME single F5 frame — and the diagram is clipped
+ * (wrapContent: false), never wrapped, so a wide diagram can't reflow or overflow.
+ */
+export function buildMermaidBlockOptions(
+	diagramText: string,
+	opts: { width: number; theme: Theme; typeLabel: string; artifactId?: string },
+): OutputBlockOptions {
+	// Unlabeled section: the header already reads "Mermaid · <type>", so a "Diagram"
+	// bar would be redundant. The diagram keeps its own colors; we only normalize tabs.
+	const lines = diagramText.split("\n").map(line => replaceTabs(line));
+	const meta = opts.artifactId ? [opts.theme.fg("dim", `artifact:${opts.artifactId.slice(0, 8)}`)] : undefined;
+	const header = renderStatusLine(
+		{ title: TOOL_TITLE, titleColor: "dim", description: opts.theme.fg("muted", opts.typeLabel), meta },
+		opts.theme,
+	);
+	// Size the frame SNUGLY to the diagram (+ one space of padding each side), capped at
+	// the available width and kept wide enough for the header caption — so the diagram
+	// feels enclosed in a small padded frame instead of spanning the whole terminal
+	// (tiny diagram) or clipping against the right border (wide diagram).
+	const maxDiagramWidth = lines.reduce((max, line) => Math.max(max, visibleWidth(line)), 0);
+	const desired = Math.max(maxDiagramWidth + 4, visibleWidth(header) + 8);
+	const width = Math.min(opts.width, Math.max(1, desired));
+	return {
+		header,
+		state: "success",
+		sections: [{ lines }],
+		width,
+		borderColor: F5_TOOL_BORDER_COLOR,
+		wrapContent: false,
+	};
+}
+
 type MermaidRenderArgs = {
 	mermaid?: string;
 };
@@ -50,63 +85,36 @@ export const mermaidRenderer = {
 			details?: RenderMermaidToolDetails;
 			isError?: boolean;
 		},
-		options: RenderResultOptions,
+		_options: RenderResultOptions,
 		uiTheme: Theme,
 		args?: MermaidRenderArgs,
 	): Component {
-		const isError = result.isError === true;
-
-		if (isError) {
+		if (result.isError === true) {
 			const errorText = result.content?.find(c => c.type === "text")?.text;
 			return new Text(formatErrorMessage(errorText, uiTheme), 0, 0);
 		}
 
-		const sections: Array<{ label?: string; lines: string[] }> = [];
-		const meta: string[] = [];
 		const rawText = result.content?.find(c => c.type === "text")?.text ?? "";
-
 		// Strip artifact reference from the plain result text (fallback path).
 		const artifactIdx = rawText.indexOf("\n\nSaved artifact:");
 		const plainText = artifactIdx >= 0 ? rawText.slice(0, artifactIdx) : rawText;
 
-		// Prefer re-rendering from the original source: this yields the themed,
-		// per-role-colored, node-tinted diagram. Fall back to the plain result text.
+		// Prefer re-rendering from the original source: themed, per-node-tinted, colored.
 		const source = args?.mermaid?.trim();
 		const diagramText = (source ? renderMermaidThemed(source, uiTheme) : null) ?? plainText;
-		const caption = source ? diagramTypeLabel(detectDiagramType(source)) : "diagram";
-
-		// Keep the diagram's own colors — do NOT recolor each line a flat tool color.
-		// Show the FULL diagram: truncating a diagram with "… N more lines" defeats the purpose.
-		const diagramLines = diagramText.split("\n").map(line => replaceTabs(line));
-		addSection(sections, "Diagram", diagramLines, uiTheme);
-
-		if (result.details?.artifactId) {
-			meta.push(uiTheme.fg("dim", `artifact:${result.details.artifactId.slice(0, 8)}`));
-		}
-
-		const header = renderStatusLine(
-			{
-				title: TOOL_TITLE,
-				titleColor: "dim",
-				description: uiTheme.fg("muted", caption),
-				meta: meta.length > 0 ? meta : undefined,
-			},
-			uiTheme,
-		);
+		const typeLabel = source ? diagramTypeLabel(detectDiagramType(source)) : "diagram";
+		const artifactId = result.details?.artifactId;
 
-		const outputBlock = new CachedOutputBlock();
+		const block = new CachedOutputBlock();
 		return {
 			render(width: number): string[] {
-				const state = options.isPartial ? "pending" : "success";
-				return outputBlock.render(
-					// Clip, don't wrap: a diagram is a fixed grid — word-wrapping reflows it
-					// and breaks alignment. Wide diagrams are truncated to the block width.
-					{ header, state, sections, width, borderColor: F5_TOOL_BORDER_COLOR, wrapContent: false },
+				return block.render(
+					buildMermaidBlockOptions(diagramText, { width, theme: uiTheme, typeLabel, artifactId }),
 					uiTheme,
 				);
 			},
 			invalidate() {
-				outputBlock.invalidate();
+				block.invalidate();
 			},
 		};
 	},