Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
import type {
ThreadErrorCode,
ThreadServerFrame,
} from '@inkeep/open-knowledge-core/acp/thread-protocol';
import { parseThreadClientFrame } from '@inkeep/open-knowledge-core/acp/thread-protocol';
import type { PinoLogger } from '../logger.ts';
import { type AcpThreadManager, ThreadOpError } from './thread-manager.ts';
interface ThreadSocket {
send(data: string): void;
close(code?: number, reason?: string): void;
on(event: 'message', listener: (data: unknown) => void): void;
on(event: 'close', listener: () => void): void;
on(event: 'error', listener: (err: Error) => void): void;
}
export function attachAcpThreadSocket(
ws: ThreadSocket,
manager: AcpThreadManager,
log: PinoLogger,
): void {
const subscriptions = new Map<string, (frame: ThreadServerFrame) => void>();
const send = (frame: ThreadServerFrame): void => {
try {
ws.send(JSON.stringify(frame));
} catch (err) {
log.warn({ err }, '[acp-thread-socket] send failed');
}
};
const sendError = (
code: Parameters<typeof errorFrame>[0],
message: string,
extra?: { reqId?: string; threadId?: string },
): void => send(errorFrame(code, message, extra));
ws.on('message', (data) => {
const raw =
typeof data === 'string' ? data : Buffer.isBuffer(data) ? data.toString('utf8') : '';
const frame = parseThreadClientFrame(raw);
if (frame === null) {
sendError('bad-frame', 'unrecognized frame');
return;
}
void (async () => {
try {
switch (frame.op) {
case 'list': {
send({ op: 'threads', threads: manager.listThreads() });
return;
}
case 'create': {
const info = await manager.createThread({
agent: frame.agent,
prompt: frame.prompt,
attachments: frame.attachments,
docName: frame.docName,
titleHint: frame.titleHint,
settings: frame.settings,
});
send({ op: 'created', reqId: frame.reqId, info });
await subscribeTo(info.threadId, 0);
return;
}
case 'subscribe': {
await subscribeTo(frame.threadId, frame.sinceSeq ?? 0, true);
return;
}
case 'resume': {
const info = await manager.resumeThread(
frame.threadId,
frame.prompt,
frame.attachments,
);
send({ op: 'resumed', reqId: frame.reqId, info });
await subscribeTo(frame.threadId, 0);
return;
}
case 'retry': {
const info = await manager.retryThread(frame.threadId);
send({ op: 'retried', reqId: frame.reqId, info });
return;
}
case 'terminal_auth_launch': {
const launch = manager.terminalAuthLaunch(frame.threadId, frame.methodId);
send({ op: 'terminal_auth_launch_ready', reqId: frame.reqId, launch });
return;
}
case 'authenticate': {
const info = await manager.authenticateThread(frame.threadId, frame.methodId);
send({ op: 'authenticated', reqId: frame.reqId, info });
return;
}
case 'delete': {
const sink = subscriptions.get(frame.threadId);
if (sink !== undefined) {
manager.unsubscribe(frame.threadId, sink);
subscriptions.delete(frame.threadId);
}
await manager.deleteThread(frame.threadId);
send({ op: 'threads', threads: manager.listThreads() });
return;
}
case 'unsubscribe': {
const sink = subscriptions.get(frame.threadId);
if (sink !== undefined) {
manager.unsubscribe(frame.threadId, sink);
subscriptions.delete(frame.threadId);
}
return;
}
case 'prompt': {
manager.sendPrompt(frame.threadId, frame.content, frame.attachments);
return;
}
case 'steer': {
manager.steerPrompt(frame.threadId, frame.content, frame.attachments);
return;
}
case 'queue_edit': {
const applied = manager.editQueued(frame.threadId, frame.id, frame.content);
if (frame.reqId !== undefined) {
if (applied) {
send({ op: 'queue_edited', reqId: frame.reqId, threadId: frame.threadId });
} else {
sendError('not-ready', 'queued message already dispatched', {
reqId: frame.reqId,
threadId: frame.threadId,
});
}
}
return;
}
case 'queue_hold': {
manager.holdQueued(frame.threadId, frame.id, frame.held);
return;
}
case 'queue_remove': {
manager.removeQueued(frame.threadId, frame.id);
return;
}
case 'queue_send_now': {
manager.sendQueuedNow(frame.threadId, frame.id);
return;
}
case 'set_chat_grant': {
manager.setChatGrant(frame.threadId, frame.grant, frame.enabled);
return;
}
case 'permission_response': {
manager.respondPermission(frame.threadId, frame.requestId, frame.outcome);
return;
}
case 'runtime_consent_response': {
manager.respondRuntimeConsent(frame.threadId, frame.requestId, frame.outcome);
return;
}
case 'pi_bridge_consent_response': {
manager.respondPiBridgeConsent(frame.threadId, frame.requestId, frame.outcome);
return;
}
case 'cancel': {
manager.cancel(frame.threadId);
return;
}
case 'set_mode': {
manager.setMode(frame.threadId, frame.modeId);
return;
}
case 'rename': {
const info = await manager.renameThread(frame.threadId, frame.title);
if (!subscriptions.has(frame.threadId)) send({ op: 'info', info });
return;
}
case 'set_config_option': {
manager.setConfigOption(frame.threadId, frame.configId, frame.value);
return;
}
case 'set_context_window': {
const info = await manager.setContextWindow(frame.threadId, frame.tokens);
send({ op: 'context_window_set', reqId: frame.reqId, info });
return;
}
case 'close': {
const sink = subscriptions.get(frame.threadId);
if (sink !== undefined) {
manager.unsubscribe(frame.threadId, sink);
subscriptions.delete(frame.threadId);
}
await manager.closeThread(frame.threadId);
send({ op: 'threads', threads: manager.listThreads() });
return;
}
}
} catch (err) {
if (err instanceof ThreadOpError) {
sendError(err.code, err.message, {
reqId: 'reqId' in frame ? frame.reqId : undefined,
threadId: 'threadId' in frame ? frame.threadId : undefined,
});
} else {
log.error({ err, op: frame.op }, '[acp-thread-socket] frame handling failed');
sendError('internal', 'internal error', {
reqId: 'reqId' in frame ? (frame as { reqId?: string }).reqId : undefined,
threadId: 'threadId' in frame ? frame.threadId : undefined,
});
}
}
})();
});
const subscribeTo = async (
threadId: string,
sinceSeq: number,
replace = false,
): Promise<void> => {
const existing = subscriptions.get(threadId);
if (existing !== undefined) {
if (!replace) return;
manager.unsubscribe(threadId, existing);
subscriptions.delete(threadId);
}
const sink = (frame: ThreadServerFrame): void => {
if (subscriptions.get(threadId) === sink) send(frame);
};
subscriptions.set(threadId, sink);
try {
await manager.subscribe(threadId, sinceSeq, sink);
if (subscriptions.get(threadId) !== sink) manager.unsubscribe(threadId, sink);
} catch (err) {
manager.unsubscribe(threadId, sink);
if (subscriptions.get(threadId) !== sink) {
if (!(err instanceof ThreadOpError)) {
log.error({ err, threadId }, '[acp-thread-socket] superseded subscription failed');
}
return;
}
subscriptions.delete(threadId);
if (err instanceof ThreadOpError) {
sendError(err.code, err.message, { threadId });
} else {
throw err;
}
}
};
ws.on('close', () => {
for (const [threadId, sink] of subscriptions) {
manager.unsubscribe(threadId, sink);
}
subscriptions.clear();
});
ws.on('error', (err) => {
log.warn({ err }, '[acp-thread-socket] socket error');
});
}
function errorFrame(
code: ThreadErrorCode,
message: string,
extra?: { reqId?: string; threadId?: string },
): ThreadServerFrame {
return { op: 'error', code, message, ...extra };
}