639 lines
19 KiB
TypeScript
639 lines
19 KiB
TypeScript
import {
|
||
createOpencode,
|
||
type OpencodeClient,
|
||
} from "@opencode-ai/sdk/v2";
|
||
import { randomUUID } from "node:crypto";
|
||
import { existsSync, readFileSync } from "node:fs";
|
||
import { chmod, mkdir, rmdir } from "node:fs/promises";
|
||
import { resolve } from "node:path";
|
||
|
||
import { config } from "../config.js";
|
||
import { logger } from "../logger.js";
|
||
import { ensureDirectory } from "../utils/fileStore.js";
|
||
import { setSandboxOwnership } from "./conversationWorkspace.js";
|
||
import {
|
||
cleanupExpiredToolOutputs,
|
||
resolveOpencodeToolOutputDirectory,
|
||
} from "./opencodeToolOutputCleanup.js";
|
||
|
||
const isDevelopmentDebugLoggingEnabled = process.env.NODE_ENV === "development";
|
||
|
||
const logDevelopmentDebug = (
|
||
message: string,
|
||
metadata: Record<string, unknown>,
|
||
) => {
|
||
if (!isDevelopmentDebugLoggingEnabled) {
|
||
return;
|
||
}
|
||
logger.info(metadata, message);
|
||
};
|
||
|
||
export type RuntimeHealth = {
|
||
healthy: boolean;
|
||
version: string;
|
||
};
|
||
|
||
type RuntimeModelOverride = {
|
||
providerID: string;
|
||
modelID: string;
|
||
};
|
||
|
||
export type PermissionReply = "once" | "always" | "reject";
|
||
export type QuestionAnswers = string[][];
|
||
|
||
type RuntimeMessage = {
|
||
info: {
|
||
id: string;
|
||
role: string;
|
||
};
|
||
};
|
||
|
||
const getRuntimeMessageRole = (message: RuntimeMessage) => message.info.role;
|
||
const getRuntimeMessageId = (message: RuntimeMessage) => message.info.id;
|
||
|
||
export class OpencodeRuntimeAdapter {
|
||
private clientPromise: Promise<OpencodeClient> | null = null;
|
||
private closeServer: (() => void) | null = null;
|
||
private toolOutputCleanupTimer: ReturnType<typeof setInterval> | null = null;
|
||
|
||
async ensureClient(): Promise<OpencodeClient> {
|
||
if (!this.clientPromise) {
|
||
this.clientPromise = this.bootstrapClient().catch((error) => {
|
||
this.clientPromise = null;
|
||
throw error;
|
||
});
|
||
}
|
||
return this.clientPromise;
|
||
}
|
||
|
||
async health(): Promise<RuntimeHealth> {
|
||
const client = await this.ensureClient();
|
||
const response = await client.global.health();
|
||
return requireData(response.data, "global.health");
|
||
}
|
||
|
||
async warmup(): Promise<void> {
|
||
const client = await this.ensureClient();
|
||
const healthStartedAt = Date.now();
|
||
const healthResponse = await client.global.health();
|
||
const health = requireData(healthResponse.data, "global.health");
|
||
logDevelopmentDebug("opencode warmup health check completed", {
|
||
elapsedMs: Math.max(0, Date.now() - healthStartedAt),
|
||
healthy: health.healthy,
|
||
version: health.version,
|
||
});
|
||
|
||
const sessionStartedAt = Date.now();
|
||
const sessionResponse = await client.session.create({
|
||
title: "tjwater-agent-warmup",
|
||
});
|
||
const session = requireData(sessionResponse.data, "session.create");
|
||
logDevelopmentDebug("opencode warmup session created", {
|
||
elapsedMs: Math.max(0, Date.now() - sessionStartedAt),
|
||
sessionId: session.id,
|
||
});
|
||
|
||
try {
|
||
const [provider, model] = config.OPENCODE_MODEL.split("/");
|
||
if (!provider || !model) {
|
||
throw new Error(
|
||
`invalid OPENCODE_MODEL; expected provider/model, received ${config.OPENCODE_MODEL}`,
|
||
);
|
||
}
|
||
const toolsStartedAt = Date.now();
|
||
const toolsResponse = await client.tool.list({ provider, model });
|
||
const tools = requireData(toolsResponse.data, "tool.list");
|
||
logDevelopmentDebug("opencode warmup tools loaded", {
|
||
elapsedMs: Math.max(0, Date.now() - toolsStartedAt),
|
||
model: config.OPENCODE_MODEL,
|
||
sessionId: session.id,
|
||
toolCount: tools.length,
|
||
});
|
||
} finally {
|
||
const cleanupStartedAt = Date.now();
|
||
let cleanupSucceeded = true;
|
||
await client.session.delete(
|
||
{ sessionID: session.id },
|
||
{ throwOnError: true },
|
||
).catch((error) => {
|
||
cleanupSucceeded = false;
|
||
logger.warn(
|
||
{ err: error, sessionId: session.id },
|
||
"failed to remove opencode warmup session",
|
||
);
|
||
});
|
||
logDevelopmentDebug("opencode warmup session cleanup completed", {
|
||
elapsedMs: Math.max(0, Date.now() - cleanupStartedAt),
|
||
sessionId: session.id,
|
||
succeeded: cleanupSucceeded,
|
||
});
|
||
}
|
||
}
|
||
|
||
async createSession(
|
||
title?: string,
|
||
options: {
|
||
conversationWorkspace?: boolean;
|
||
workspaceRoot?: string;
|
||
} = {},
|
||
) {
|
||
const client = await this.ensureClient();
|
||
if (!options.conversationWorkspace) {
|
||
const response = await client.session.create({ title });
|
||
return requireData(response.data, "session.create");
|
||
}
|
||
|
||
const workspaceRoot = resolve(
|
||
options.workspaceRoot ?? config.RESULT_REF_IMPORT_DIR,
|
||
);
|
||
const directory = resolve(workspaceRoot, `conversation-${randomUUID()}`);
|
||
await ensureDirectory(workspaceRoot);
|
||
await chmod(workspaceRoot, 0o700);
|
||
await mkdir(directory, { mode: 0o700 });
|
||
await setSandboxOwnership(directory);
|
||
try {
|
||
const response = await client.session.create({
|
||
directory,
|
||
title,
|
||
permission: [
|
||
{ permission: "read", pattern: `${directory}/**`, action: "allow" },
|
||
{ permission: "edit", pattern: `${directory}/**`, action: "ask" },
|
||
],
|
||
});
|
||
return requireData(response.data, "session.create");
|
||
} catch (error) {
|
||
await rmdir(directory).catch(() => undefined);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
async getSession(sessionId: string) {
|
||
const client = await this.ensureClient();
|
||
const response = await client.session.get({ sessionID: sessionId });
|
||
return requireData(response.data, "session.get");
|
||
}
|
||
|
||
async sendPrompt(sessionId: string, text: string) {
|
||
await this.prompt(sessionId, text);
|
||
// 当前 SDK 响应风格下，prompt() 本身不会直接返回完整 assistant parts，
|
||
// 所以这里紧跟一次 messages() 回读，给上层路由统一消费。
|
||
return this.messages(sessionId);
|
||
}
|
||
|
||
async prompt(
|
||
sessionId: string,
|
||
text: string,
|
||
model?: RuntimeModelOverride,
|
||
) {
|
||
const client = await this.ensureClient();
|
||
const startedAt = Date.now();
|
||
logDevelopmentDebug(
|
||
"dispatching opencode session.prompt",
|
||
{
|
||
sessionId,
|
||
model: model ?? null,
|
||
textChars: text.length,
|
||
},
|
||
);
|
||
await client.session.prompt({
|
||
sessionID: sessionId,
|
||
model,
|
||
parts: [{ type: "text", text }],
|
||
});
|
||
logDevelopmentDebug(
|
||
"opencode session.prompt returned",
|
||
{
|
||
sessionId,
|
||
elapsedMs: Math.max(0, Date.now() - startedAt),
|
||
},
|
||
);
|
||
}
|
||
|
||
async messages(sessionId: string, limit = 20) {
|
||
const client = await this.ensureClient();
|
||
const messages = await client.session.messages({
|
||
sessionID: sessionId,
|
||
limit,
|
||
});
|
||
return requireData(messages.data, "session.messages");
|
||
}
|
||
|
||
async revertMessage(sessionId: string, messageId: string) {
|
||
const client = await this.ensureClient();
|
||
const response = await client.session.revert({
|
||
sessionID: sessionId,
|
||
messageID: messageId,
|
||
});
|
||
return response.data;
|
||
}
|
||
|
||
async removeMessage(sessionId: string, messageId: string) {
|
||
const client = await this.ensureClient();
|
||
const response = await client.session.deleteMessage({
|
||
sessionID: sessionId,
|
||
messageID: messageId,
|
||
});
|
||
return response.data;
|
||
}
|
||
|
||
async revertToUserMessage(sessionId: string, options: { userOrdinal: number }) {
|
||
const messages = await this.messages(sessionId, 80);
|
||
const userMessages = messages.filter(
|
||
(message) => getRuntimeMessageRole(message) === "user",
|
||
);
|
||
const targetUserMessage = userMessages[options.userOrdinal - 1];
|
||
|
||
if (!targetUserMessage) {
|
||
if (messages.length === 0 && options.userOrdinal === 1) {
|
||
logger.warn(
|
||
{ sessionId, userOrdinal: options.userOrdinal },
|
||
"skipping opencode revert because runtime session has no messages",
|
||
);
|
||
return;
|
||
}
|
||
throw new Error("target user message not found to revert");
|
||
}
|
||
|
||
const targetMessageId = getRuntimeMessageId(targetUserMessage);
|
||
const targetIndex = messages.findIndex(
|
||
(message) => getRuntimeMessageId(message) === targetMessageId,
|
||
);
|
||
const messagesToRemove = targetIndex >= 0 ? messages.slice(targetIndex) : [targetUserMessage];
|
||
|
||
await this.revertMessage(sessionId, targetMessageId);
|
||
|
||
for (const message of messagesToRemove.reverse()) {
|
||
const messageId = getRuntimeMessageId(message);
|
||
try {
|
||
await this.removeMessage(sessionId, messageId);
|
||
} catch (error) {
|
||
logger.warn(
|
||
{ err: error, sessionId, messageId },
|
||
"failed to remove reverted opencode message",
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
async abortSession(sessionId: string) {
|
||
const client = await this.ensureClient();
|
||
const response = await client.session.abort({
|
||
sessionID: sessionId,
|
||
});
|
||
return requireData(response.data, "session.abort");
|
||
}
|
||
|
||
async waitForSessionIdle(sessionId: string, timeoutMs = config.OPENCODE_TIMEOUT_MS) {
|
||
const client = await this.ensureClient();
|
||
const startedAt = Date.now();
|
||
|
||
while (Date.now() - startedAt < timeoutMs) {
|
||
const response = await client.session.status({});
|
||
const statuses = requireData(response.data, "session.status");
|
||
const status = statuses[sessionId];
|
||
if (!status || status.type === "idle") {
|
||
return;
|
||
}
|
||
await delay(100);
|
||
}
|
||
|
||
logger.warn(
|
||
{ sessionId, timeoutMs },
|
||
"timed out waiting for opencode session to become idle",
|
||
);
|
||
}
|
||
|
||
async subscribeEvents(directory?: string) {
|
||
const client = await this.ensureClient();
|
||
const response = await client.event.subscribe(
|
||
directory ? { directory } : undefined,
|
||
);
|
||
return response.stream;
|
||
}
|
||
|
||
async replyPermission(options: {
|
||
requestId: string;
|
||
sessionId?: string;
|
||
directory?: string;
|
||
reply: PermissionReply;
|
||
message?: string;
|
||
}) {
|
||
const client = await this.ensureClient();
|
||
const directory = await this.resolveInteractionDirectory(options);
|
||
if ("permission" in client && client.permission?.reply) {
|
||
const response = await client.permission.reply({
|
||
requestID: options.requestId,
|
||
directory,
|
||
reply: options.reply,
|
||
message: options.message,
|
||
});
|
||
return requireData(response.data, "permission.reply");
|
||
}
|
||
|
||
if ("permission" in client && client.permission?.respond && options.sessionId) {
|
||
const response = await client.permission.respond({
|
||
sessionID: options.sessionId,
|
||
permissionID: options.requestId,
|
||
directory,
|
||
response: options.reply,
|
||
});
|
||
return requireData(response.data, "permission.respond");
|
||
}
|
||
|
||
throw new Error("opencode permission reply API is unavailable");
|
||
}
|
||
|
||
async replyQuestion(options: {
|
||
requestId: string;
|
||
sessionId?: string;
|
||
directory?: string;
|
||
answers: QuestionAnswers;
|
||
}) {
|
||
const client = await this.ensureClient();
|
||
const directory = await this.resolveInteractionDirectory(options);
|
||
if ("question" in client && client.question?.reply) {
|
||
try {
|
||
const response = await client.question.reply({
|
||
requestID: options.requestId,
|
||
directory,
|
||
answers: options.answers,
|
||
});
|
||
return requireData(response.data, "question.reply");
|
||
} catch (error) {
|
||
if (!options.sessionId) {
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
|
||
const v2Question = (client as unknown as {
|
||
v2?: {
|
||
session?: {
|
||
question?: {
|
||
reply?: (parameters: {
|
||
sessionID: string;
|
||
requestID: string;
|
||
directory?: string;
|
||
questionV2Reply: { answers: QuestionAnswers };
|
||
}) => Promise<{ data: unknown }>;
|
||
};
|
||
};
|
||
};
|
||
}).v2?.session?.question;
|
||
|
||
if (v2Question?.reply && options.sessionId) {
|
||
const response = await v2Question.reply({
|
||
sessionID: options.sessionId,
|
||
requestID: options.requestId,
|
||
directory,
|
||
questionV2Reply: {
|
||
answers: options.answers,
|
||
},
|
||
});
|
||
return requireData(response.data, "question.v2.reply");
|
||
}
|
||
|
||
throw new Error("opencode question reply API is unavailable");
|
||
}
|
||
|
||
async rejectQuestion(options: {
|
||
requestId: string;
|
||
sessionId?: string;
|
||
directory?: string;
|
||
}) {
|
||
const client = await this.ensureClient();
|
||
const directory = await this.resolveInteractionDirectory(options);
|
||
if ("question" in client && client.question?.reject) {
|
||
try {
|
||
const response = await client.question.reject({
|
||
requestID: options.requestId,
|
||
directory,
|
||
});
|
||
return requireData(response.data, "question.reject");
|
||
} catch (error) {
|
||
if (!options.sessionId) {
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
|
||
const v2Question = (client as unknown as {
|
||
v2?: {
|
||
session?: {
|
||
question?: {
|
||
reject?: (parameters: {
|
||
sessionID: string;
|
||
requestID: string;
|
||
directory?: string;
|
||
}) => Promise<{ data: unknown }>;
|
||
};
|
||
};
|
||
};
|
||
}).v2?.session?.question;
|
||
|
||
if (v2Question?.reject && options.sessionId) {
|
||
const response = await v2Question.reject({
|
||
sessionID: options.sessionId,
|
||
requestID: options.requestId,
|
||
directory,
|
||
});
|
||
return requireData(response.data, "question.v2.reject");
|
||
}
|
||
|
||
throw new Error("opencode question reject API is unavailable");
|
||
}
|
||
|
||
private async resolveInteractionDirectory(options: {
|
||
sessionId?: string;
|
||
directory?: string;
|
||
}): Promise<string | undefined> {
|
||
const directory = options.directory?.trim();
|
||
if (directory) {
|
||
return directory;
|
||
}
|
||
if (!options.sessionId) {
|
||
return undefined;
|
||
}
|
||
const session = await this.getSession(options.sessionId);
|
||
return session.directory;
|
||
}
|
||
|
||
async dispose(): Promise<void> {
|
||
if (this.toolOutputCleanupTimer) {
|
||
clearInterval(this.toolOutputCleanupTimer);
|
||
this.toolOutputCleanupTimer = null;
|
||
}
|
||
this.closeServer?.();
|
||
this.closeServer = null;
|
||
this.clientPromise = null;
|
||
}
|
||
|
||
private async bootstrapClient(): Promise<OpencodeClient> {
|
||
await this.cleanupToolOutputs();
|
||
|
||
// embedded 模式下，把服务内工具桥地址注入到 opencode 进程环境里，
|
||
// 这样 .opencode/tools 下的自定义工具可以回调本服务。
|
||
process.env.TJWATER_AGENT_INTERNAL_BASE_URL = `http://127.0.0.1:${config.PORT}`;
|
||
process.env.TJWATER_AGENT_INTERNAL_TOKEN =
|
||
config.AGENT_INTERNAL_TOKEN ??
|
||
process.env.TJWATER_AGENT_INTERNAL_TOKEN ??
|
||
"";
|
||
process.env.RESULT_REF_IMPORT_DIR = config.RESULT_REF_IMPORT_DIR;
|
||
|
||
logger.info(
|
||
{
|
||
hostname: config.OPENCODE_HOSTNAME,
|
||
port: config.OPENCODE_PORT,
|
||
model: config.OPENCODE_MODEL,
|
||
mode: config.OPENCODE_MODE,
|
||
},
|
||
"starting opencode server in embedded mode",
|
||
);
|
||
|
||
const startedAt = Date.now();
|
||
let runtime;
|
||
try {
|
||
runtime = await createOpencode({
|
||
hostname: config.OPENCODE_HOSTNAME,
|
||
port: config.OPENCODE_PORT,
|
||
timeout: config.OPENCODE_TIMEOUT_MS,
|
||
config: buildOpencodeConfig(),
|
||
});
|
||
} catch (error) {
|
||
if (isMissingOpencodeCli(error)) {
|
||
throw new Error(
|
||
"embedded mode requires the opencode CLI to be installed and available in PATH",
|
||
);
|
||
}
|
||
throw error;
|
||
}
|
||
|
||
logger.info(
|
||
{
|
||
elapsedMs: Math.max(0, Date.now() - startedAt),
|
||
hostname: config.OPENCODE_HOSTNAME,
|
||
port: config.OPENCODE_PORT,
|
||
mode: config.OPENCODE_MODE,
|
||
},
|
||
"opencode server started in embedded mode",
|
||
);
|
||
|
||
this.closeServer = () => {
|
||
runtime.server.close();
|
||
};
|
||
this.startToolOutputCleanupLoop();
|
||
|
||
return runtime.client;
|
||
}
|
||
|
||
private async cleanupToolOutputs(): Promise<void> {
|
||
const directory = resolveOpencodeToolOutputDirectory();
|
||
const ttlMs = config.RESULT_REF_TTL_HOURS * 60 * 60 * 1000;
|
||
try {
|
||
const result = await cleanupExpiredToolOutputs(directory, ttlMs);
|
||
if (result.removed > 0) {
|
||
logger.info(
|
||
{ directory, ...result },
|
||
"removed expired opencode tool output files",
|
||
);
|
||
}
|
||
} catch (error) {
|
||
logger.warn(
|
||
{ err: error, directory },
|
||
"failed to clean expired opencode tool output files",
|
||
);
|
||
}
|
||
}
|
||
|
||
private startToolOutputCleanupLoop(): void {
|
||
if (this.toolOutputCleanupTimer) {
|
||
return;
|
||
}
|
||
this.toolOutputCleanupTimer = setInterval(() => {
|
||
void this.cleanupToolOutputs();
|
||
}, config.RESULT_REF_CLEANUP_INTERVAL_MS);
|
||
this.toolOutputCleanupTimer.unref();
|
||
}
|
||
}
|
||
|
||
export const opencodeRuntime = new OpencodeRuntimeAdapter();
|
||
|
||
function buildOpencodeConfig(): Record<string, unknown> {
|
||
return deepMerge(
|
||
deepMerge(readProjectOpencodeConfig(), readEnvOpencodeConfig()),
|
||
{
|
||
model: config.OPENCODE_MODEL,
|
||
tool_output: {
|
||
max_bytes: config.MAX_INLINE_RESULT_BYTES,
|
||
max_lines: 2000,
|
||
},
|
||
},
|
||
);
|
||
}
|
||
|
||
function readProjectOpencodeConfig(): Record<string, unknown> {
|
||
const path = resolve(process.cwd(), "opencode.json");
|
||
if (!existsSync(path)) {
|
||
return {};
|
||
}
|
||
return parseConfigJson(readFileSync(path, "utf8"), path);
|
||
}
|
||
|
||
function readEnvOpencodeConfig(): Record<string, unknown> {
|
||
const content = process.env.OPENCODE_CONFIG_CONTENT;
|
||
if (!content?.trim()) {
|
||
return {};
|
||
}
|
||
return parseConfigJson(content, "OPENCODE_CONFIG_CONTENT");
|
||
}
|
||
|
||
function parseConfigJson(content: string, source: string): Record<string, unknown> {
|
||
const parsed = JSON.parse(content) as unknown;
|
||
if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
|
||
throw new Error(`${source} must contain a JSON object`);
|
||
}
|
||
return parsed as Record<string, unknown>;
|
||
}
|
||
|
||
function deepMerge(
|
||
left: Record<string, unknown>,
|
||
right: Record<string, unknown>,
|
||
): Record<string, unknown> {
|
||
const next = { ...left };
|
||
for (const [key, value] of Object.entries(right)) {
|
||
const existing = next[key];
|
||
if (isPlainObject(existing) && isPlainObject(value)) {
|
||
next[key] = deepMerge(existing, value);
|
||
} else {
|
||
next[key] = value;
|
||
}
|
||
}
|
||
return next;
|
||
}
|
||
|
||
function isPlainObject(value: unknown): value is Record<string, unknown> {
|
||
return typeof value === "object" && value !== null && !Array.isArray(value);
|
||
}
|
||
|
||
function isMissingOpencodeCli(error: unknown): error is NodeJS.ErrnoException {
|
||
return (
|
||
typeof error === "object" &&
|
||
error !== null &&
|
||
"code" in error &&
|
||
(error as NodeJS.ErrnoException).code === "ENOENT"
|
||
);
|
||
}
|
||
|
||
function requireData<T>(data: T | undefined, operation: string): T {
|
||
if (data === undefined) {
|
||
throw new Error(`${operation} returned no data`);
|
||
}
|
||
return data;
|
||
}
|
||
|
||
function delay(ms: number) {
|
||
return new Promise<void>((resolve) => {
|
||
setTimeout(resolve, ms);
|
||
});
|
||
}
|