@norman-else/dsh-claude 0.1.9 → 0.1.10

package/lib/index.mjs

@@ -1,12 +1,13 @@
-import { _ as CLAUDE_UPDATE_CHECK_PATH, a as latestClaudeTasks, b as TASK_TOOL_NAMES, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_CODE_PRESET_ID, g as CLAUDE_PROJECTION_PATH, h as CLAUDE_DOCTOR_PATH, i as latestClaudeSessionBinding, l as redactText, m as CLAUDE_CODE_PROVIDER_IDS, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_CODE_PROVIDER, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_UPDATE_PATH } from "./events-BVQkPmjg.mjs";
-import { a as ClaudeCommandBridge, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-CQ9dBVyY.mjs";
-import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-DUmmDvBm.mjs";
+import { _ as CLAUDE_PROJECTION_PATH, a as latestClaudeTasks, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_CODE_PRESET_ID, g as CLAUDE_GLOBAL_SETTINGS_PATH, h as CLAUDE_DOCTOR_PATH, i as latestClaudeSessionBinding, l as redactText, m as CLAUDE_CODE_PROVIDER_IDS, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_CODE_PROVIDER, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_UPDATE_CHECK_PATH, x as TASK_TOOL_NAMES, y as CLAUDE_UPDATE_PATH } from "./events-6xTApIQw.mjs";
+import { a as ClaudeCommandBridge, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-C8Yx_rNY.mjs";
+import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-B0NrA4Hi.mjs";
 import z from "@deepseek-ai/schemastery";
 import { CallId, LlmAdapter, ReasoningEffortId, createToolResultMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { randomUUID } from "node:crypto";
 import { chmod, mkdir, opendir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { dirname, extname, join, resolve } from "node:path";
 import { dshHomePath, resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { homedir } from "node:os";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { EventEmitter } from "node:events";
 import { DSH_ENV_PREFIX, SENSITIVE_ENV_PATTERN } from "@deepseek-ai/dsh-subprocess";
@@ -2457,6 +2458,11 @@ async function checkPluginUpdate(deps = {}) {
 		};
 	}
 }
+async function verifyInstalledVersion(installation, expectedVersion) {
+	if (dependencySpec(await readManifest(join(installation.profileDir, "package.json"))) !== expectedVersion) throw new Error("DSH plugin update completed without updating the profile dependency");
+	const installedManifest = await readManifest(join(installation.profileDir, "node_modules", ...PLUGIN_PACKAGE_NAME.split("/"), "package.json"));
+	if (installedManifest.name !== "@norman-else/dsh-claude" || installedManifest.version !== expectedVersion) throw new Error("DSH plugin update completed without installing the requested version");
+}
 async function updatePlugin(deps = {}) {
 	const { version, installation } = await packageContext(deps);
 	if (installation === void 0 || installation.source !== "registry") throw new Error("Plugin update is unavailable for this installation");
@@ -2479,8 +2485,8 @@ async function updatePlugin(deps = {}) {
 			"plugin",
 			"--profile",
 			installation.profile,
-			"update",
-			PLUGIN_PACKAGE_NAME
+			"add",
+			`${PLUGIN_PACKAGE_NAME}@${latest}`
 		],
 		cwd: installation.profileDir,
 		env: {},
@@ -2497,8 +2503,9 @@ async function updatePlugin(deps = {}) {
 		const detail = handle.collected.stderr?.readFrom(0).text ?? "";
 		throw new Error(`DSH plugin update failed (${outcome.exitCode ?? outcome.signal ?? "unknown exit"}): ${safeMessage(detail)}`);
 	}
+	await verifyInstalledVersion(installation, latest);
 	return {
-		currentVersion: version,
+		currentVersion: latest,
 		latestVersion: latest,
 		source: "registry",
 		state: "current",
@@ -2536,6 +2543,194 @@ function registerClaudeUpdateRoutes(ctx, runtime, deps = {}) {
 	}), `dsh-claude: ${route.method} ${route.path}`);
 }
 //#endregion
+//#region src/global-settings.ts
+const MAX_SETTINGS_BYTES = 262144;
+const MAX_REQUEST_BYTES = 8192;
+const MAX_STYLE_BYTES = 65536;
+const MAX_STYLE_FILES = 256;
+const BUILTIN_OUTPUT_STYLES = [
+	"Default",
+	"Proactive",
+	"Concise",
+	"Explanatory",
+	"Learning"
+];
+const STYLE_NAME = /^[\p{L}\p{N}][\p{L}\p{N} ._()\[\]-]{0,127}$/u;
+function pathsFor(deps) {
+	const root = join(homedir(), ".claude");
+	return {
+		settingsFile: deps.paths?.settingsFile ?? join(root, "settings.json"),
+		outputStylesDir: deps.paths?.outputStylesDir ?? join(root, "output-styles")
+	};
+}
+function object(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+async function readDocument(path) {
+	try {
+		const text = await readFile(path, "utf8");
+		if (Buffer.byteLength(text) > MAX_SETTINGS_BYTES) throw new Error("Claude Code settings file is too large");
+		const parsed = object(JSON.parse(text));
+		if (parsed === void 0) throw new Error("Claude Code settings file must contain a JSON object");
+		return parsed;
+	} catch (error) {
+		if (error.code === "ENOENT") return {};
+		throw error;
+	}
+}
+function frontmatterName(text) {
+	if (!text.startsWith("---\n") && !text.startsWith("---\r\n")) return void 0;
+	const normalized = text.replaceAll("\r\n", "\n");
+	const end = normalized.indexOf("\n---\n", 4);
+	if (end < 0) return void 0;
+	for (const line of normalized.slice(4, end).split("\n")) {
+		const match = /^name:\s*(.+?)\s*$/.exec(line);
+		if (match?.[1] === void 0) continue;
+		const raw = match[1];
+		const value = raw.startsWith("\"") && raw.endsWith("\"") || raw.startsWith("'") && raw.endsWith("'") ? raw.slice(1, -1) : raw;
+		return STYLE_NAME.test(value) ? value : void 0;
+	}
+}
+async function userOutputStyleOptions(directory) {
+	const options = [];
+	let entries;
+	try {
+		entries = await opendir(directory);
+	} catch (error) {
+		if (error.code === "ENOENT") return options;
+		throw error;
+	}
+	for await (const entry of entries) {
+		if (options.length >= MAX_STYLE_FILES) break;
+		if (!entry.isFile() || extname(entry.name).toLowerCase() !== ".md") continue;
+		try {
+			const text = await readFile(join(directory, entry.name), "utf8");
+			if (Buffer.byteLength(text) > MAX_STYLE_BYTES) continue;
+			const name = frontmatterName(text) ?? entry.name.slice(0, -3);
+			if (STYLE_NAME.test(name)) options.push({
+				value: name,
+				label: name,
+				source: "user"
+			});
+		} catch {}
+	}
+	return options;
+}
+const DESCRIPTORS = [{
+	key: "outputStyle",
+	kind: "select",
+	effect: "new-session",
+	async options(paths) {
+		const builtIn = BUILTIN_OUTPUT_STYLES.map((value) => ({
+			value,
+			label: value,
+			source: "built-in"
+		}));
+		const user = await userOutputStyleOptions(paths.outputStylesDir);
+		const seen = new Set(builtIn.map((option) => option.value));
+		return [...builtIn, ...user.filter((option) => !seen.has(option.value)).sort((a, b) => a.label.localeCompare(b.label))];
+	},
+	read(document, options) {
+		const value = document.outputStyle;
+		return typeof value === "string" && STYLE_NAME.test(value) ? value : "Default";
+	},
+	apply(document, value, options) {
+		if (typeof value !== "string" || !options.some((option) => option.value === value)) throw new Error("Invalid value for global setting outputStyle");
+		if (value === "Default") delete document.outputStyle;
+		else document.outputStyle = value;
+	}
+}];
+const DESCRIPTOR_BY_KEY = new Map(DESCRIPTORS.map((descriptor) => [descriptor.key, descriptor]));
+let pendingWrite = Promise.resolve();
+async function views(document, paths) {
+	return { settings: await Promise.all(DESCRIPTORS.map(async (descriptor) => {
+		const discovered = await descriptor.options(paths);
+		const value = descriptor.read(document, discovered);
+		const options = discovered.some((option) => option.value === value) ? discovered : [...discovered, {
+			value,
+			label: value,
+			source: "configured"
+		}];
+		return {
+			key: descriptor.key,
+			kind: descriptor.kind,
+			value,
+			options,
+			effect: descriptor.effect
+		};
+	})) };
+}
+async function readGlobalSettings(deps = {}) {
+	const paths = pathsFor(deps);
+	return views(await readDocument(paths.settingsFile), paths);
+}
+async function atomicWrite(path, document) {
+	await mkdir(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		await writeFile(temporary, `${JSON.stringify(document, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 384,
+			flag: "wx"
+		});
+		await chmod(temporary, 384);
+		await rename(temporary, path);
+		await chmod(path, 384);
+	} finally {
+		await rm(temporary, { force: true }).catch(() => void 0);
+	}
+}
+function updateGlobalSettings(changes, deps = {}) {
+	const changeObject = object(changes);
+	if (changeObject === void 0 || Object.keys(changeObject).length === 0) return Promise.reject(/* @__PURE__ */ new Error("Global settings changes must be a non-empty object"));
+	for (const key of Object.keys(changeObject)) if (!DESCRIPTOR_BY_KEY.has(key)) return Promise.reject(/* @__PURE__ */ new Error(`Unsupported global setting: ${key}`));
+	const paths = pathsFor(deps);
+	const operation = pendingWrite.catch(() => void 0).then(async () => {
+		const document = await readDocument(paths.settingsFile);
+		for (const [key, value] of Object.entries(changeObject)) {
+			const descriptor = DESCRIPTOR_BY_KEY.get(key);
+			descriptor.apply(document, value, await descriptor.options(paths));
+		}
+		await atomicWrite(paths.settingsFile, document);
+		return views(document, paths);
+	});
+	pendingWrite = operation;
+	return operation;
+}
+async function requestJson(req) {
+	const declared = Number(req.headers["content-length"] ?? 0);
+	if (!Number.isFinite(declared) || declared < 0 || declared > MAX_REQUEST_BYTES) throw new Error("Request body is too large");
+	const chunks = [];
+	let bytes = 0;
+	for await (const chunk of req) {
+		const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		bytes += data.byteLength;
+		if (bytes > MAX_REQUEST_BYTES) throw new Error("Request body is too large");
+		chunks.push(data);
+	}
+	const body = object(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+	if (body === void 0 || Object.keys(body).some((key) => key !== "changes")) throw new Error("Invalid global settings request");
+	return body.changes;
+}
+function registerClaudeGlobalSettingsRoute(ctx, deps = {}) {
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: CLAUDE_GLOBAL_SETTINGS_PATH,
+		handler: async (req, res) => {
+			if (req.method !== "GET" && req.method !== "PATCH") return json(res, 405, { error: "method not allowed" });
+			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+			try {
+				json(res, 200, req.method === "GET" ? await readGlobalSettings(deps) : await updateGlobalSettings(await requestJson(req), deps));
+			} catch (error) {
+				json(res, 400, { error: error instanceof Error ? error.message : "Invalid global settings request" });
+			}
+		}
+	}), "dsh-claude: global settings");
+}
+//#endregion
 //#region src/index.ts
 const name = "llm-claude";
 const inject = [
@@ -2749,6 +2944,7 @@ async function apply(ctx, config) {
 	ctx.inject(["webServer"], (webCtx) => {
 		registerClaudeDoctorRoutes(webCtx, webCtx.subprocess, supervisor, supervisorConfig, resolutionError);
 		registerClaudeUpdateRoutes(webCtx, webCtx.subprocess);
+		registerClaudeGlobalSettingsRoute(webCtx);
 		registerClaudeProjectionRoute(webCtx, sidecar, (sessionId) => {
 			const agent = webCtx.agents.get(sessionId);
 			return agent !== void 0 && webCtx.agentPresets.composedPreset(agent.ctx) === "claude";