mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-20 01:07:23 +00:00
208 lines
6.3 KiB
TypeScript
208 lines
6.3 KiB
TypeScript
import {
|
|
CommandId,
|
|
OrchestratorMcpFailure,
|
|
type OrchestrationV2AppThread,
|
|
type OrchestrationV2Command,
|
|
type ThreadMetadataMcpAction,
|
|
type ThreadMetadataMcpUpdateInput,
|
|
type ThreadMetadataMcpUpdateResult,
|
|
ThreadId,
|
|
} from "@hanzodev/contracts";
|
|
import * as Context from "effect/Context";
|
|
import * as SecureRandom from "effect/crypto/SecureRandom";
|
|
import * as DateTime from "effect/DateTime";
|
|
import * as Effect from "effect/Effect";
|
|
import * as Layer from "effect/Layer";
|
|
|
|
import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
|
|
import type { McpInvocationScope } from "./McpInvocationContext.ts";
|
|
import { threadNotFound } from "./threadAccess.ts";
|
|
|
|
export class ThreadMetadataMcpService extends Context.Service<
|
|
ThreadMetadataMcpService,
|
|
{
|
|
readonly update: (
|
|
scope: McpInvocationScope,
|
|
input: ThreadMetadataMcpUpdateInput,
|
|
) => Effect.Effect<ThreadMetadataMcpUpdateResult, OrchestratorMcpFailure>;
|
|
}
|
|
>()("hanzo/mcp/ThreadMetadataMcpService") {}
|
|
|
|
function failure(code: OrchestratorMcpFailure["code"], message: string): OrchestratorMcpFailure {
|
|
return new OrchestratorMcpFailure({ code, message });
|
|
}
|
|
|
|
function errorMessage(error: unknown): string {
|
|
return error instanceof Error ? error.message : String(error);
|
|
}
|
|
|
|
function stablePart(value: string): string {
|
|
return encodeURIComponent(value);
|
|
}
|
|
|
|
function commandId(input: {
|
|
readonly scope: McpInvocationScope;
|
|
readonly threadId: ThreadId;
|
|
readonly action: ThreadMetadataMcpAction;
|
|
readonly requestKey: string;
|
|
}): CommandId {
|
|
return CommandId.make(
|
|
[
|
|
"command",
|
|
"mcp",
|
|
stablePart(input.scope.requestNamespace),
|
|
"thread-update",
|
|
stablePart(input.threadId),
|
|
stablePart(input.action),
|
|
stablePart(input.requestKey),
|
|
].join(":"),
|
|
);
|
|
}
|
|
|
|
function metadataCommand(input: {
|
|
readonly commandId: CommandId;
|
|
readonly threadId: ThreadId;
|
|
readonly update: ThreadMetadataMcpUpdateInput;
|
|
}): Extract<OrchestrationV2Command, { readonly type: "thread.metadata.update" }> {
|
|
switch (input.update.action) {
|
|
case "rename":
|
|
return {
|
|
type: "thread.metadata.update",
|
|
commandId: input.commandId,
|
|
threadId: input.threadId,
|
|
title: input.update.title!,
|
|
};
|
|
case "regenerate_title":
|
|
return {
|
|
type: "thread.metadata.update",
|
|
commandId: input.commandId,
|
|
threadId: input.threadId,
|
|
regenerateTitle: true,
|
|
};
|
|
}
|
|
}
|
|
|
|
function resultFromThread(input: {
|
|
readonly action: ThreadMetadataMcpAction;
|
|
readonly commandId: CommandId;
|
|
readonly sequence: number;
|
|
readonly thread: Pick<
|
|
OrchestrationV2AppThread,
|
|
"id" | "title" | "titleRegeneration" | "linkedPullRequest" | "updatedAt"
|
|
>;
|
|
}): ThreadMetadataMcpUpdateResult {
|
|
return {
|
|
threadId: input.thread.id,
|
|
action: input.action,
|
|
commandId: input.commandId,
|
|
sequence: input.sequence,
|
|
title: input.thread.title,
|
|
titleRegeneration:
|
|
input.thread.titleRegeneration === undefined || input.thread.titleRegeneration === null
|
|
? null
|
|
: {
|
|
requestId: input.thread.titleRegeneration.requestId,
|
|
startedAt: DateTime.formatIso(input.thread.titleRegeneration.startedAt),
|
|
},
|
|
linkedPullRequest: input.thread.linkedPullRequest ?? null,
|
|
updatedAt: DateTime.formatIso(input.thread.updatedAt),
|
|
};
|
|
}
|
|
|
|
const make = Effect.gen(function* () {
|
|
const random = yield* SecureRandom.SecureRandom;
|
|
const threadManagement = yield* ThreadManagementService.ThreadManagementService;
|
|
|
|
const update = Effect.fn("ThreadMetadataMcpService.update")(function* (
|
|
scope: McpInvocationScope,
|
|
input: ThreadMetadataMcpUpdateInput,
|
|
) {
|
|
if (!scope.capabilities.has("orchestration")) {
|
|
return yield* failure(
|
|
"capability_denied",
|
|
"This MCP credential does not grant orchestration capabilities.",
|
|
);
|
|
}
|
|
|
|
const threadId = input.threadId ?? scope.thread?.threadId;
|
|
if (threadId === undefined) {
|
|
return yield* failure(
|
|
"target_required",
|
|
"Pass threadId: this MCP client is not running inside a Hanzo thread.",
|
|
);
|
|
}
|
|
const shell = yield* threadManagement
|
|
.getThreadShell(threadId)
|
|
.pipe(
|
|
Effect.mapError((error) =>
|
|
failure(
|
|
"orchestration_error",
|
|
`Unable to locate thread ${threadId}: ${errorMessage(error)}`,
|
|
),
|
|
),
|
|
);
|
|
if (shell === null || shell.deletedAt !== null) {
|
|
return yield* threadNotFound(
|
|
threadManagement,
|
|
scope,
|
|
threadId,
|
|
`Thread ${threadId} was not found.`,
|
|
);
|
|
}
|
|
const requestKey =
|
|
input.clientRequestId === undefined ? yield* random.uuidV4() : input.clientRequestId;
|
|
const updateCommandId = commandId({
|
|
scope,
|
|
threadId,
|
|
action: input.action,
|
|
requestKey,
|
|
});
|
|
const dispatched = yield* threadManagement
|
|
.dispatch(
|
|
metadataCommand({
|
|
commandId: updateCommandId,
|
|
threadId,
|
|
update: input,
|
|
}),
|
|
)
|
|
.pipe(
|
|
Effect.mapError((error) =>
|
|
failure(
|
|
"orchestration_error",
|
|
`Unable to ${input.action} for thread ${threadId}: ${errorMessage(error)}`,
|
|
),
|
|
),
|
|
);
|
|
const metadataEvent = dispatched.storedEvents.find(
|
|
(stored) => stored.event.type === "thread.metadata-updated",
|
|
);
|
|
// Retries may find stored events compacted away; answer from the projection.
|
|
const thread =
|
|
metadataEvent?.event.type === "thread.metadata-updated"
|
|
? metadataEvent.event.payload
|
|
: yield* threadManagement
|
|
.getThreadShell(threadId)
|
|
.pipe(Effect.mapError((error) => failure("orchestration_error", errorMessage(error))));
|
|
if (thread === null) {
|
|
return yield* failure(
|
|
"orchestration_error",
|
|
`Thread ${threadId} metadata update completed without a resultant state.`,
|
|
);
|
|
}
|
|
return resultFromThread({
|
|
action: input.action,
|
|
commandId: updateCommandId,
|
|
sequence: dispatched.sequence,
|
|
thread,
|
|
});
|
|
});
|
|
|
|
return ThreadMetadataMcpService.of({ update });
|
|
});
|
|
|
|
export const layer: Layer.Layer<
|
|
ThreadMetadataMcpService,
|
|
never,
|
|
SecureRandom.SecureRandom | ThreadManagementService.ThreadManagementService
|
|
> = Layer.effect(ThreadMetadataMcpService, make);
|