godot-daedalus_backend 1.0.0

package/src/providers/provider-config-store.ts

@@ -0,0 +1,164 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import keytar from "keytar";
+import { getProviderConfigPath } from "../app-paths.js";
+
+const KEYTAR_SERVICE: string = "Godot Daedalus";
+const DEEPSEEK_ACCOUNT: string = "deepseek_api_key";
+
+export type ProviderConfigInput = {
+	provider: "deepseek";
+	apiKey?: string | undefined;
+	model?: string | undefined;
+	baseUrl?: string | undefined;
+};
+
+export type StoredProviderConfig = {
+	provider: "deepseek";
+	model?: string | undefined;
+	baseUrl?: string | undefined;
+	keyStorage: "keytar";
+	updatedAt: string;
+};
+
+export type ProviderConfigWithSecret = StoredProviderConfig & {
+	apiKey?: string | undefined;
+};
+
+export type ProviderConfigStatus = {
+	provider: "deepseek";
+	configured: boolean;
+	model: string | null;
+	baseUrl: string | null;
+	apiKeyMasked: string | null;
+	keyStorage: "keytar";
+	configPath: string;
+	updatedAt: string | null;
+};
+
+function normalizeOptionalString(value: string | undefined): string | undefined {
+	const trimmed: string | undefined = value?.trim();
+	return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+
+function maskApiKey(apiKey: string | null): string | null {
+	if (apiKey === null || apiKey.length === 0) {
+		return null;
+	}
+
+	if (apiKey.length <= 8) {
+		return "********";
+	}
+
+	return `${apiKey.slice(0, 3)}...${apiKey.slice(-4)}`;
+}
+
+async function readStoredProviderConfig(): Promise<StoredProviderConfig | null> {
+	const filePath: string = getProviderConfigPath();
+
+	try {
+		const raw: string = await readFile(filePath, "utf8");
+		const parsed: unknown = JSON.parse(raw);
+
+		if (typeof parsed !== "object" || parsed === null) {
+			return null;
+		}
+
+		const record: Record<string, unknown> = parsed as Record<string, unknown>;
+		if (record.provider !== "deepseek") {
+			return null;
+		}
+
+		const config: StoredProviderConfig = {
+			provider: "deepseek",
+			keyStorage: "keytar",
+			updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : ""
+		};
+
+		if (typeof record.model === "string" && record.model.trim().length > 0) {
+			config.model = record.model.trim();
+		}
+
+		if (typeof record.baseUrl === "string" && record.baseUrl.trim().length > 0) {
+			config.baseUrl = record.baseUrl.trim();
+		}
+
+		return config;
+	} catch {
+		return null;
+	}
+}
+
+async function writeStoredProviderConfig(config: StoredProviderConfig): Promise<void> {
+	const filePath: string = getProviderConfigPath();
+	await mkdir(dirname(filePath), { recursive: true });
+	await writeFile(filePath, JSON.stringify(config, null, 2), "utf8");
+}
+
+export async function saveProviderConfig(input: ProviderConfigInput): Promise<ProviderConfigStatus> {
+	const apiKey: string | undefined = normalizeOptionalString(input.apiKey);
+	if (apiKey !== undefined) {
+		await keytar.setPassword(KEYTAR_SERVICE, DEEPSEEK_ACCOUNT, apiKey);
+	}
+
+	const existing: StoredProviderConfig | null = await readStoredProviderConfig();
+	const config: StoredProviderConfig = {
+		provider: "deepseek",
+		keyStorage: "keytar",
+		updatedAt: new Date().toISOString()
+	};
+
+	const model: string | undefined = normalizeOptionalString(input.model) ?? existing?.model;
+	const baseUrl: string | undefined = normalizeOptionalString(input.baseUrl) ?? existing?.baseUrl;
+
+	if (model !== undefined) {
+		config.model = model;
+	}
+
+	if (baseUrl !== undefined) {
+		config.baseUrl = baseUrl;
+	}
+
+	await writeStoredProviderConfig(config);
+	return getProviderConfigStatus();
+}
+
+export async function loadProviderConfigWithSecret(): Promise<ProviderConfigWithSecret | null> {
+	const stored: StoredProviderConfig | null = await readStoredProviderConfig();
+	const apiKey: string | null = await keytar.getPassword(KEYTAR_SERVICE, DEEPSEEK_ACCOUNT);
+
+	if (stored === null && apiKey === null) {
+		return null;
+	}
+
+	return {
+		provider: "deepseek",
+		keyStorage: "keytar",
+		updatedAt: stored?.updatedAt ?? "",
+		model: stored?.model,
+		baseUrl: stored?.baseUrl,
+		apiKey: apiKey ?? undefined
+	};
+}
+
+export async function getProviderConfigStatus(): Promise<ProviderConfigStatus> {
+	const stored: StoredProviderConfig | null = await readStoredProviderConfig();
+	const apiKey: string | null = await keytar.getPassword(KEYTAR_SERVICE, DEEPSEEK_ACCOUNT);
+
+	return {
+		provider: "deepseek",
+		configured: apiKey !== null,
+		model: stored?.model ?? null,
+		baseUrl: stored?.baseUrl ?? null,
+		apiKeyMasked: maskApiKey(apiKey),
+		keyStorage: "keytar",
+		configPath: getProviderConfigPath(),
+		updatedAt: stored?.updatedAt ?? null
+	};
+}
+
+export async function clearProviderConfig(): Promise<ProviderConfigStatus> {
+	await keytar.deletePassword(KEYTAR_SERVICE, DEEPSEEK_ACCOUNT);
+	await rm(getProviderConfigPath(), { force: true });
+	return getProviderConfigStatus();
+}

package/src/server/client-session.ts

@@ -0,0 +1,93 @@
+import type { AiChatParams, ChatMessage, ModelProfile } from "../protocol/types.js";
+import type { DeepSeekAgentContinuation } from "../providers/deepseek-agent.js";
+import type { DeepSeekChatOptions } from "../providers/deepseek-client.js";
+import type { SessionMetadata } from "../session/session-store.js";
+import { ApprovalGateway } from "../tools/approval-gateway.js";
+import type { SkillId } from "../skills/registry.js";
+import { getDefaultModelProfile } from "../tokens/model-profiles.js";
+import type { WorkspaceConfig } from "../workspace/types.js";
+import type { WorkflowRunState } from "../workflow/types.js";
+
+export type PendingGuide = {
+	id: string;
+	clientGuideId: string;
+	text: string;
+	anchorRequestId?: string | undefined;
+	createdAt: string;
+	updatedAt: string;
+};
+
+export type ThinkingEventBuffer = {
+	sessionId: string;
+	requestId: string;
+	text: string;
+};
+
+export type PendingAiContinuation = {
+	params: AiChatParams;
+	options: DeepSeekChatOptions;
+	continuation: DeepSeekAgentContinuation;
+	allowedToolNames?: readonly string[] | undefined;
+	userMessage: string;
+	requestId: string;
+	userCreatedAt: string;
+	stream: boolean;
+	workflowState?: WorkflowRunState | undefined;
+};
+
+export type ClientSession = {
+	deepseekApiKey?: string | undefined;
+	deepseekModel?: string | undefined;
+	deepseekBaseUrl?: string | undefined;
+	godotExecutablePath?: string | undefined;
+	godotProjectPath?: string | undefined;
+	messages: ChatMessage[];
+	modelProfile: ModelProfile;
+	approvalGateway: ApprovalGateway;
+	activeSkillId?: SkillId | undefined;
+	activeWorkspace?: WorkspaceConfig | undefined;
+	sessionId?: string | undefined;
+	sessionTitle?: string | undefined;
+	summaryMessage?: ChatMessage | undefined;
+	summaryCoveredMessageCount?: number | undefined;
+	pendingAiContinuations: Map<string, PendingAiContinuation>;
+	thinkingEventBuffers: Map<string, ThinkingEventBuffer>;
+	activeAbortControllers: Map<string, AbortController>;
+	inFlightRequestIds: Set<string>;
+	completedRequestIds: Map<string, number>;
+	eventPersistQueue: Promise<void>;
+	pendingGuides: PendingGuide[];
+	fullSessionLoadPromise?: Promise<void> | undefined;
+};
+
+export function createClientSession(defaultWorkspace: WorkspaceConfig | undefined): ClientSession {
+	return {
+		messages: [],
+		modelProfile: getDefaultModelProfile(),
+		approvalGateway: new ApprovalGateway(),
+		activeWorkspace: defaultWorkspace,
+		pendingAiContinuations: new Map(),
+		thinkingEventBuffers: new Map(),
+		activeAbortControllers: new Map(),
+		inFlightRequestIds: new Set(),
+		completedRequestIds: new Map(),
+		pendingGuides: [],
+		eventPersistQueue: Promise.resolve()
+	};
+}
+
+export function clearActiveSession(session: ClientSession): void {
+	session.sessionId = undefined;
+	session.sessionTitle = undefined;
+	session.messages = [];
+	session.fullSessionLoadPromise = undefined;
+	session.summaryMessage = undefined;
+	session.summaryCoveredMessageCount = undefined;
+	session.pendingGuides = [];
+}
+
+export function applySessionMetadata(session: ClientSession, metadata: SessionMetadata): void {
+	session.sessionId = metadata.id;
+	session.sessionTitle = metadata.title;
+	session.activeSkillId = metadata.activeSkillId as SkillId | undefined;
+}

package/src/server/request-dispatcher.ts

@@ -0,0 +1,74 @@
+import type WebSocket from "ws";
+import type { ClientRequest } from "../protocol/types.js";
+import type { McpHost } from "../mcp/mcp-host.js";
+import type { ClientSession } from "./client-session.js";
+
+export type RequestHandler = (
+	socket: WebSocket,
+	request: ClientRequest,
+	session: ClientSession,
+	mcpHost: McpHost
+) => Promise<void> | void;
+
+export const REQUEST_HANDLER_METHODS: readonly ClientRequest["method"][] = [
+	"ping",
+	"provider.configure",
+	"provider.config.get",
+	"provider.config.set",
+	"provider.config.clear",
+	"ai.chat",
+	"ai.next_step_hints",
+	"ai.cancel",
+	"prompt.list",
+	"skill.list",
+	"skill.activate",
+	"session.reset",
+	"session.info",
+	"session.create",
+	"session.open",
+	"session.timeline",
+	"session.list",
+	"session.archive",
+	"session.archived.list",
+	"session.archived.restore",
+	"session.archived.delete",
+	"session.save",
+	"session.delete",
+	"session.rename",
+	"session.compress",
+	"session.summary",
+	"session.guide.add",
+	"session.guide.update",
+	"session.guide.delete",
+	"mcp.listTools",
+	"mcp.callTool",
+	"mcp.listResources",
+	"mcp.readResource",
+	"mcp.config.list",
+	"mcp.config.add",
+	"mcp.config.remove",
+	"mcp.config.setEnabled",
+	"fileChange.create",
+	"fileChange.overwrite",
+	"fileChange.delete",
+	"approval.list",
+	"approval.mode.set",
+	"approval.approve",
+	"approval.reject",
+	"environment.configure",
+	"editor.context.update",
+	"editor.tool.result",
+	"workspace.list",
+	"workspace.select",
+	"workspace.info"
+] as const;
+
+export const REQUEST_HANDLERS: ReadonlyMap<ClientRequest["method"], RequestHandler | null> = new Map(
+	REQUEST_HANDLER_METHODS.map((method: ClientRequest["method"]): [ClientRequest["method"], RequestHandler | null] => [method, null])
+);
+
+export function assertKnownRequestMethod(method: ClientRequest["method"]): void {
+	if (!REQUEST_HANDLERS.has(method)) {
+		throw new Error(`Request method is missing dispatcher registration: ${method}`);
+	}
+}

package/src/server/response-helpers.ts

@@ -0,0 +1,33 @@
+import type WebSocket from "ws";
+import type { ServerEvent } from "../protocol/types.js";
+import { sendJson } from "./send-json.js";
+
+export function sendOk(socket: WebSocket, id: string, result: unknown): void {
+	sendJson(socket, {
+		type: "response",
+		id,
+		ok: true,
+		result
+	});
+}
+
+export function sendError(socket: WebSocket, id: string, code: string, message: string): void {
+	sendJson(socket, {
+		type: "response",
+		id,
+		ok: false,
+		error: {
+			code,
+			message
+		}
+	});
+}
+
+export function sendEvent(socket: WebSocket, id: string, event: ServerEvent["event"], data: unknown): void {
+	sendJson(socket, {
+		type: "event",
+		id,
+		event,
+		data
+	});
+}

package/src/server/send-json.ts

@@ -0,0 +1,8 @@
+import WebSocket from "ws";
+import type { ServerEvent, ServerResponse } from "../protocol/types.js";
+
+export function sendJson(socket: WebSocket, message: ServerResponse | ServerEvent): void {
+	if (socket.readyState === WebSocket.OPEN) {
+		socket.send(JSON.stringify(message));
+	}
+}