576 lines
16 KiB
TypeScript
576 lines
16 KiB
TypeScript
import {
|
||
createOpencode,
|
||
createOpencodeClient,
|
||
type OpencodeClient,
|
||
} from "@opencode-ai/sdk/v2";
|
||
import { existsSync, readFileSync } from "node:fs";
|
||
import { createServer } from "node:net";
|
||
import { resolve } from "node:path";
|
||
|
||
import { config } from "../config.js";
|
||
import { logger } from "../logger.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;
|
||
|
||
const isTcpPortAvailable = (hostname: string, port: number) =>
|
||
new Promise<boolean>((resolve, reject) => {
|
||
const server = createServer();
|
||
server.unref();
|
||
server.once("error", (error: NodeJS.ErrnoException) => {
|
||
if (error.code === "EADDRINUSE") {
|
||
resolve(false);
|
||
return;
|
||
}
|
||
reject(error);
|
||
});
|
||
server.listen({ host: hostname, port, exclusive: true }, () => {
|
||
server.close((error) => (error ? reject(error) : resolve(true)));
|
||
});
|
||
});
|
||
|
||
export const resolveEmbeddedOpencodePort = async (
|
||
hostname: string,
|
||
configuredPort: number,
|
||
) => {
|
||
if (configuredPort === 0) {
|
||
return 0;
|
||
}
|
||
return (await isTcpPortAvailable(hostname, configuredPort))
|
||
? configuredPort
|
||
: 0;
|
||
};
|
||
|
||
export class OpencodeRuntimeAdapter {
|
||
private clientPromise: Promise<OpencodeClient> | null = null;
|
||
private closeServer: (() => void) | 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) {
|
||
const client = await this.ensureClient();
|
||
const response = await client.session.create({
|
||
title,
|
||
});
|
||
return requireData(response.data, "session.create");
|
||
}
|
||
|
||
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() {
|
||
const client = await this.ensureClient();
|
||
const response = await client.event.subscribe();
|
||
return response.stream;
|
||
}
|
||
|
||
async replyPermission(options: {
|
||
requestId: string;
|
||
sessionId?: string;
|
||
reply: PermissionReply;
|
||
message?: string;
|
||
}) {
|
||
const client = await this.ensureClient();
|
||
if ("permission" in client && client.permission?.reply) {
|
||
const response = await client.permission.reply({
|
||
requestID: options.requestId,
|
||
reply: options.reply,
|
||
message: options.message,
|
||
});
|
||
return response.data;
|
||
}
|
||
|
||
if ("permission" in client && client.permission?.respond && options.sessionId) {
|
||
const response = await client.permission.respond({
|
||
sessionID: options.sessionId,
|
||
permissionID: options.requestId,
|
||
response: options.reply,
|
||
});
|
||
return response.data;
|
||
}
|
||
|
||
throw new Error("opencode permission reply API is unavailable");
|
||
}
|
||
|
||
async replyQuestion(options: {
|
||
requestId: string;
|
||
sessionId?: string;
|
||
answers: QuestionAnswers;
|
||
}) {
|
||
const client = await this.ensureClient();
|
||
if ("question" in client && client.question?.reply) {
|
||
try {
|
||
const response = await client.question.reply({
|
||
requestID: options.requestId,
|
||
answers: options.answers,
|
||
});
|
||
return response.data;
|
||
} catch (error) {
|
||
if (!options.sessionId) {
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
|
||
const v2Question = (client as unknown as {
|
||
v2?: {
|
||
session?: {
|
||
question?: {
|
||
reply?: (parameters: {
|
||
sessionID: string;
|
||
requestID: 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,
|
||
questionV2Reply: {
|
||
answers: options.answers,
|
||
},
|
||
});
|
||
return response.data;
|
||
}
|
||
|
||
throw new Error("opencode question reply API is unavailable");
|
||
}
|
||
|
||
async rejectQuestion(options: {
|
||
requestId: string;
|
||
sessionId?: string;
|
||
}) {
|
||
const client = await this.ensureClient();
|
||
if ("question" in client && client.question?.reject) {
|
||
try {
|
||
const response = await client.question.reject({
|
||
requestID: options.requestId,
|
||
});
|
||
return response.data;
|
||
} catch (error) {
|
||
if (!options.sessionId) {
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
|
||
const v2Question = (client as unknown as {
|
||
v2?: {
|
||
session?: {
|
||
question?: {
|
||
reject?: (parameters: {
|
||
sessionID: string;
|
||
requestID: string;
|
||
}) => Promise<{ data: unknown }>;
|
||
};
|
||
};
|
||
};
|
||
}).v2?.session?.question;
|
||
|
||
if (v2Question?.reject && options.sessionId) {
|
||
const response = await v2Question.reject({
|
||
sessionID: options.sessionId,
|
||
requestID: options.requestId,
|
||
});
|
||
return response.data;
|
||
}
|
||
|
||
throw new Error("opencode question reject API is unavailable");
|
||
}
|
||
|
||
async dispose(): Promise<void> {
|
||
this.closeServer?.();
|
||
this.closeServer = null;
|
||
this.clientPromise = null;
|
||
}
|
||
|
||
private async bootstrapClient(): Promise<OpencodeClient> {
|
||
if (config.OPENCODE_MODE === "client") {
|
||
logger.info(
|
||
{
|
||
baseUrl: config.OPENCODE_CLIENT_BASE_URL,
|
||
mode: config.OPENCODE_MODE,
|
||
},
|
||
"connecting to opencode server in client mode",
|
||
);
|
||
return createOpencodeClient({
|
||
baseUrl: config.OPENCODE_CLIENT_BASE_URL,
|
||
});
|
||
}
|
||
|
||
// 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 ??
|
||
"";
|
||
|
||
const port = await resolveEmbeddedOpencodePort(
|
||
config.OPENCODE_HOSTNAME,
|
||
config.OPENCODE_PORT,
|
||
);
|
||
if (port !== config.OPENCODE_PORT) {
|
||
logger.warn(
|
||
{
|
||
hostname: config.OPENCODE_HOSTNAME,
|
||
configuredPort: config.OPENCODE_PORT,
|
||
},
|
||
"configured opencode port is occupied; falling back to a dynamic port",
|
||
);
|
||
}
|
||
|
||
logger.info(
|
||
{
|
||
hostname: config.OPENCODE_HOSTNAME,
|
||
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,
|
||
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; otherwise set OPENCODE_MODE=client and provide OPENCODE_CLIENT_BASE_URL",
|
||
);
|
||
}
|
||
throw error;
|
||
}
|
||
|
||
logger.info(
|
||
{
|
||
elapsedMs: Math.max(0, Date.now() - startedAt),
|
||
hostname: config.OPENCODE_HOSTNAME,
|
||
baseUrl: runtime.server.url,
|
||
mode: config.OPENCODE_MODE,
|
||
},
|
||
"opencode server started in embedded mode",
|
||
);
|
||
|
||
this.closeServer = () => {
|
||
runtime.server.close();
|
||
};
|
||
|
||
return runtime.client;
|
||
}
|
||
}
|
||
|
||
export const opencodeRuntime = new OpencodeRuntimeAdapter();
|
||
|
||
function buildOpencodeConfig(): Record<string, unknown> {
|
||
return deepMerge(
|
||
deepMerge(readProjectOpencodeConfig(), readEnvOpencodeConfig()),
|
||
{
|
||
model: config.OPENCODE_MODEL,
|
||
},
|
||
);
|
||
}
|
||
|
||
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);
|
||
});
|
||
}
|