@f5xc-salesdemos/xcsh 19.42.2 → 19.43.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5xc-salesdemos/xcsh",
-	"version": "19.42.2",
+	"version": "19.43.0",
 	"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.0",
+		"@f5xc-salesdemos/pi-agent-core": "19.43.0",
+		"@f5xc-salesdemos/pi-ai": "19.43.0",
+		"@f5xc-salesdemos/pi-natives": "19.43.0",
+		"@f5xc-salesdemos/pi-resource-management": "19.43.0",
+		"@f5xc-salesdemos/pi-tui": "19.43.0",
+		"@f5xc-salesdemos/pi-utils": "19.43.0",
 		"@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.0",
+	"commit": "d8fefbb60bd96f414bb9c21da7df270bd10876eb",
+	"shortCommit": "d8fefbb",
 	"branch": "main",
-	"tag": "v19.42.2",
-	"commitDate": "2026-06-24T03:15:55Z",
-	"buildDate": "2026-06-24T03:45:49.205Z",
+	"tag": "v19.43.0",
+	"commitDate": "2026-06-24T04:38:55Z",
+	"buildDate": "2026-06-24T05:01:00.600Z",
 	"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/d8fefbb60bd96f414bb9c21da7df270bd10876eb",
+	"releaseUrl": "https://github.com/f5xc-salesdemos/xcsh/releases/tag/v19.43.0"
 };

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/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;