@norman-else/dsh-claude 0.1.8 → 0.1.10

package/lib/index.d.mts

@@ -176,7 +176,7 @@ type ClaudeTurnStreamEvent = {
 type ClaudeThinkingMode = 'off' | 'ultracode' | EffortLevel;
 interface ClaudeTurnRequest {
   agent: Agent;
-  prompt: string;
+  prompt: SDKUserMessage['message']['content'];
   model?: string;
   thinkingMode?: ClaudeThinkingMode;
   signal?: AbortSignal;

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";
@@ -1866,15 +1867,81 @@ const NO_RETRY_POLICY = Object.freeze({
 	maxDelayMs: 1e4,
 	jitterRatio: .1
 });
-function extractDirectUserText(messages) {
-	for (let index = messages.length - 1; index >= 0; index -= 1) {
-		const message = messages[index];
-		if (message?.role !== "user" || message.source.kind !== "user") continue;
+function abortIfRequested(signal) {
+	if (signal?.aborted !== true) return;
+	if (signal.reason instanceof Error) throw signal.reason;
+	const error = /* @__PURE__ */ new Error("Claude Code input resolution aborted");
+	error.name = "AbortError";
+	throw error;
+}
+function finiteNonNegative(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function validateImageRef(ref, attachments, imageIndex) {
+	const limits = attachments.imageLimits;
+	if (!limits.mediaTypes.includes(ref.mediaType)) throw new Error(`dsh-claude: image ${imageIndex} has an unsupported media type`);
+	if (!finiteNonNegative(ref.bytes) || ref.bytes > limits.maxImageBytes) throw new Error(`dsh-claude: image ${imageIndex} exceeds the configured byte limit`);
+	const maxDimension = "maxImageDimension" in limits && finiteNonNegative(limits.maxImageDimension) ? limits.maxImageDimension : void 0;
+	if (!finiteNonNegative(ref.width) || !finiteNonNegative(ref.height) || ref.width * ref.height > limits.maxImagePixels || maxDimension !== void 0 && (ref.width > maxDimension || ref.height > maxDimension)) throw new Error(`dsh-claude: image ${imageIndex} exceeds the configured dimension limit`);
+}
+function imageBlock(data, mediaType) {
+	return {
+		type: "image",
+		source: {
+			type: "base64",
+			media_type: mediaType,
+			data: Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("base64")
+		}
+	};
+}
+/** Resolve only the newest direct human message; Claude's session owns history. */
+async function resolveDirectUserPrompt(messages, attachments, signal) {
+	const message = [...messages].reverse().find((candidate) => candidate.role === "user" && candidate.source.kind === "user");
+	if (message === void 0) throw new Error("dsh-claude: no direct human input was present in this model step");
+	const imageRefs = message.content.filter((block) => block.type === "image").map((block) => block.attachment);
+	const limits = attachments.imageLimits;
+	if (imageRefs.length > limits.maxImagesPerMessage) throw new Error("dsh-claude: prompt exceeds the configured image-count limit");
+	let declaredBytes = 0;
+	imageRefs.forEach((ref, index) => {
+		validateImageRef(ref, attachments, index + 1);
+		declaredBytes += ref.bytes;
+		if (!Number.isSafeInteger(declaredBytes) || declaredBytes > limits.maxMessageImageBytes) throw new Error("dsh-claude: prompt exceeds the configured aggregate image-byte limit");
+	});
+	if (imageRefs.length === 0) {
 		const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
 		if (text.length > 0) return text;
-		if (message.content.some((block) => block.type === "image")) throw new Error("dsh-claude: image-only prompts are not supported in v0.1; include a text prompt");
+		throw new Error("dsh-claude: the newest direct human message has no supported content");
 	}
-	throw new Error("dsh-claude: no direct human text was present in this model step");
+	const content = [];
+	let imageIndex = 0;
+	let verifiedBytes = 0;
+	for (const block of message.content) {
+		abortIfRequested(signal);
+		if (block.type === "text") {
+			content.push({
+				type: "text",
+				text: block.text
+			});
+			continue;
+		}
+		if (block.type !== "image") continue;
+		imageIndex += 1;
+		let stored;
+		try {
+			stored = await attachments.readImage(block.attachment, signal);
+		} catch {
+			abortIfRequested(signal);
+			throw new Error(`dsh-claude: image ${imageIndex} could not be read or verified`);
+		}
+		abortIfRequested(signal);
+		validateImageRef(stored.ref, attachments, imageIndex);
+		if (stored.data.byteLength !== stored.ref.bytes || stored.ref.mediaType !== block.attachment.mediaType) throw new Error(`dsh-claude: image ${imageIndex} failed attachment verification`);
+		verifiedBytes += stored.data.byteLength;
+		if (!Number.isSafeInteger(verifiedBytes) || verifiedBytes > limits.maxMessageImageBytes) throw new Error("dsh-claude: prompt exceeds the configured aggregate image-byte limit");
+		content.push(imageBlock(stored.data, stored.ref.mediaType));
+	}
+	if (content.length === 0) throw new Error("dsh-claude: the newest direct human message has no supported content");
+	return content;
 }
 function tokenUsage(usage) {
 	const normalized = {
@@ -1897,11 +1964,13 @@ function resolveAgent(agents, options) {
 var ClaudeCodeAdapter = class extends LlmAdapter {
 	#supervisor;
 	#agents;
+	#attachments;
 	#presetIdFor;
-	constructor(supervisor, agents, presetIdFor) {
+	constructor(supervisor, agents, attachments, presetIdFor) {
 		super();
 		this.#supervisor = supervisor;
 		this.#agents = agents;
+		this.#attachments = attachments;
 		this.#presetIdFor = presetIdFor;
 	}
 	providerInfo(provider) {
@@ -1919,7 +1988,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 			id: model.id,
 			name: model.name,
 			description: model.description,
-			inputModalities: ["text"]
+			inputModalities: ["text", "image"]
 		}));
 	}
 	async resolveModel(provider, model) {
@@ -1931,7 +2000,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 			name: known?.name ?? `Claude Code ${model}`,
 			...known === void 0 ? {} : { description: known.description },
 			...contextWindow === void 0 ? {} : { context: { contextWindow } },
-			inputModalities: ["text"],
+			inputModalities: ["text", "image"],
 			reasoning: { efforts: THINKING_MODES.map((mode) => ({
 				id: ReasoningEffortId(mode.id),
 				name: mode.name,
@@ -1944,7 +2013,23 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		const agent = resolveAgent(this.#agents, options);
 		if (this.#presetIdFor(agent) !== "claude") throw new Error(`dsh-claude: provider ${CLAUDE_CODE_PROVIDER} is available only to the ${CLAUDE_CODE_PRESET_ID} preset`);
 		const thinkingMode = thinkingModeFor(options.reasoningEffort);
-		const prompt = extractDirectUserText(options.messages);
+		let prompt;
+		try {
+			prompt = await resolveDirectUserPrompt(options.messages, this.#attachments, options.signal);
+		} catch (error) {
+			if (error.name !== "AbortError") throw error;
+			yield {
+				type: "finish",
+				reason: {
+					kind: "aborted",
+					failure: {
+						code: "aborted",
+						message: error instanceof Error ? error.message : "Claude Code input resolution aborted"
+					}
+				}
+			};
+			return;
+		}
 		const events = await this.#supervisor.runTurn({
 			agent,
 			prompt,
@@ -2029,8 +2114,8 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		if (!completed) throw new Error("dsh-claude: Claude turn stream ended without a result");
 	}
 };
-function createClaudeCodeAdapter(supervisor, agents, presetIdFor) {
-	return new ClaudeCodeAdapter(supervisor, agents, presetIdFor);
+function createClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor) {
+	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor);
 }
 //#endregion
 //#region src/http.ts
@@ -2373,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");
@@ -2395,8 +2485,8 @@ async function updatePlugin(deps = {}) {
 			"plugin",
 			"--profile",
 			installation.profile,
-			"update",
-			PLUGIN_PACKAGE_NAME
+			"add",
+			`${PLUGIN_PACKAGE_NAME}@${latest}`
 		],
 		cwd: installation.profileDir,
 		env: {},
@@ -2413,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",
@@ -2452,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 = [
@@ -2461,7 +2740,8 @@ const inject = [
 	"commands",
 	"subprocess",
 	"approval",
-	"userQuestions"
+	"userQuestions",
+	"attachments"
 ];
 const Config = z.object({
 	executablePath: z.string().default(""),
@@ -2601,7 +2881,7 @@ async function apply(ctx, config) {
 	let resolutionError;
 	try {
 		supervisorConfig.executablePath = (await resolveClaudeExecutable(ctx.subprocess, config.executablePath === void 0 || config.executablePath.length === 0 ? void 0 : config.executablePath)).path;
-		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, (agent) => ctx.agentPresets.composedPreset(agent.ctx)));
+		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, ctx.attachments, (agent) => ctx.agentPresets.composedPreset(agent.ctx)));
 		ctx.effect(() => {
 			const mounted = /* @__PURE__ */ new Map();
 			const pending = /* @__PURE__ */ new Set();
@@ -2664,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";