wehub-resource-sync
864 lines
25 KiB
TypeScript
864 lines
25 KiB
TypeScript
import {
|
|
existsSync,
|
|
mkdirSync,
|
|
readdirSync,
|
|
readFileSync,
|
|
writeFileSync,
|
|
} from "node:fs";
|
|
import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import {
|
|
type AgentPlugin,
|
|
type AgentTool,
|
|
type AgentToolContext,
|
|
ClineCore,
|
|
createTool,
|
|
} from "@cline/core";
|
|
import YAML from "yaml";
|
|
import { z } from "zod";
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Types
|
|
// ---------------------------------------------------------------------------
|
|
|
|
type SessionManager = ClineCore;
|
|
|
|
/** Minimal plugin host interface injected by the runtime via globalThis. */
|
|
interface ClinePluginHost {
|
|
emitEvent?: (name: string, payload?: unknown) => void;
|
|
}
|
|
|
|
declare global {
|
|
var __clinePluginHost: ClinePluginHost | undefined;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Constants
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
|
|
const BUNDLED_AGENTS_DIR = join(MODULE_DIR, "agents");
|
|
const BUNDLED_SKILLS_DIR = join(MODULE_DIR, "skills");
|
|
|
|
function resolveDefaultHomeDir(): string {
|
|
const envHome = process?.env?.HOME?.trim();
|
|
if (envHome && envHome !== "~") {
|
|
return envHome;
|
|
}
|
|
const envUserProfile = process?.env?.USERPROFILE?.trim();
|
|
if (envUserProfile) {
|
|
return envUserProfile;
|
|
}
|
|
const envHomeDrive = process?.env?.HOMEDRIVE?.trim();
|
|
const envHomePath = process?.env?.HOMEPATH?.trim();
|
|
if (envHomeDrive && envHomePath) {
|
|
return `${envHomeDrive}${envHomePath}`;
|
|
}
|
|
return "~";
|
|
}
|
|
|
|
function resolveClineDirPath(): string {
|
|
const explicitDir = process.env.CLINE_DIR?.trim();
|
|
if (explicitDir) {
|
|
return explicitDir;
|
|
}
|
|
return join(resolveDefaultHomeDir(), ".cline");
|
|
}
|
|
|
|
function resolveClineDataDirPath(): string {
|
|
const explicitDir = process.env.CLINE_DATA_DIR?.trim();
|
|
if (explicitDir) {
|
|
return explicitDir;
|
|
}
|
|
return join(resolveClineDirPath(), "data");
|
|
}
|
|
|
|
function resolveGlobalAgentsDirPath(): string {
|
|
return join(resolveClineDataDirPath(), "settings", "agents");
|
|
}
|
|
|
|
const HANDOFFS_DIR = join(
|
|
resolveClineDataDirPath(),
|
|
"plugins",
|
|
"subagents",
|
|
"handoffs",
|
|
);
|
|
const GLOBAL_SKILLS_DIR = join(resolveClineDataDirPath(), "settings", "skills");
|
|
|
|
// Agent and skill definitions live in the `agents/` and `skills/`
|
|
// directories alongside this file. They are loaded at runtime from disk.
|
|
|
|
/** Safe identifier pattern for conversation IDs used in filesystem paths. */
|
|
const SAFE_ID_RE = /^[A-Za-z0-9_-]+$/;
|
|
const HANDOFF_PATH_ALLOWED_RE = /^[A-Za-z0-9._/-]+$/;
|
|
const HANDOFF_PATH_MAX_LENGTH = 240;
|
|
|
|
const envOr = (key: string, fallback: string): string =>
|
|
process.env[key]?.trim() || fallback;
|
|
|
|
const DEFAULT_PROVIDER_ID = envOr("CLINE_SUBAGENT_PROVIDER_ID", "cline");
|
|
const DEFAULT_MODEL_ID = envOr(
|
|
"CLINE_SUBAGENT_MODEL_ID",
|
|
"anthropic/claude-sonnet-4.6",
|
|
);
|
|
type SubagentBackendMode = "auto" | "hub" | "local";
|
|
|
|
const DEFAULT_BACKEND_MODE = envOr("CLINE_SUBAGENTS_BACKEND_MODE", "auto");
|
|
const DEFAULT_AGENT_PRESET = envOr("CLINE_SUBAGENT_DEFAULT_PRESET", "phantom");
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Agent & Skill Definitions
|
|
// ---------------------------------------------------------------------------
|
|
|
|
interface AgentDefinition {
|
|
name: string;
|
|
description?: string;
|
|
providerId?: string;
|
|
modelId?: string;
|
|
systemPrompt: string;
|
|
cwd?: string;
|
|
maxIterations?: number;
|
|
source: "bundled" | "global" | "project";
|
|
}
|
|
|
|
interface SkillDefinition {
|
|
name: string;
|
|
description?: string;
|
|
content: string;
|
|
source: "bundled" | "global" | "project";
|
|
}
|
|
|
|
interface RunningSubagent {
|
|
sessionId: string;
|
|
parentSessionId?: string;
|
|
name: string;
|
|
task: string;
|
|
agent?: string;
|
|
startedAt: number;
|
|
status: "running" | "completed" | "failed";
|
|
resultText?: string;
|
|
error?: string;
|
|
finishReason?: string;
|
|
completedAt?: number;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// State
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const subagents = new Map<string, RunningSubagent>();
|
|
let sessionManagerPromise: Promise<SessionManager> | undefined;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Cast a fully-typed tool to the `AgentTool<unknown, unknown>` expected by
|
|
* the plugin API's `registerTool` method. This is safe at runtime because the
|
|
* registry only invokes `execute` with validated input that matches the
|
|
* tool's `inputSchema`.
|
|
*/
|
|
function toRegisteredTool<I, O>(
|
|
tool: AgentTool<I, O>,
|
|
): AgentTool<unknown, unknown> {
|
|
return tool as AgentTool<unknown, unknown>;
|
|
}
|
|
|
|
function optStr(v: unknown): string | undefined {
|
|
return typeof v === "string" && v.trim() ? v.trim() : undefined;
|
|
}
|
|
|
|
function optInt(v: unknown): number | undefined {
|
|
return typeof v === "number" && Number.isFinite(v) && v > 0
|
|
? Math.floor(v)
|
|
: undefined;
|
|
}
|
|
|
|
function parseFrontmatter(md: string): {
|
|
data: Record<string, unknown>;
|
|
body: string;
|
|
} {
|
|
const m = md.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
|
|
if (!m) return { data: {}, body: md.trim() };
|
|
try {
|
|
const frontmatter = m[1] ?? "";
|
|
const body = m[2] ?? "";
|
|
const parsed = YAML.parse(frontmatter);
|
|
return {
|
|
data:
|
|
parsed && typeof parsed === "object" && !Array.isArray(parsed)
|
|
? (parsed as Record<string, unknown>)
|
|
: {},
|
|
body: body.trim(),
|
|
};
|
|
} catch {
|
|
// Malformed YAML frontmatter — treat as plain markdown with no metadata.
|
|
return { data: {}, body: md.trim() };
|
|
}
|
|
}
|
|
|
|
function readMarkdownDir(
|
|
dirPath: string,
|
|
source: AgentDefinition["source"],
|
|
): Array<{
|
|
name: string;
|
|
data: Record<string, unknown>;
|
|
body: string;
|
|
source: typeof source;
|
|
}> {
|
|
if (!existsSync(dirPath)) return [];
|
|
const results: Array<{
|
|
name: string;
|
|
data: Record<string, unknown>;
|
|
body: string;
|
|
source: typeof source;
|
|
}> = [];
|
|
for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
|
|
if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
|
|
try {
|
|
const { data, body } = parseFrontmatter(
|
|
readFileSync(join(dirPath, entry.name), "utf8"),
|
|
);
|
|
if (!body) continue;
|
|
const name = optStr(data.name) ?? entry.name.replace(/\.md$/, "");
|
|
results.push({ name, data, body, source });
|
|
} catch {}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
function readAgentDefinitions(baseCwd: string): AgentDefinition[] {
|
|
const dirs: Array<{ path: string; source: AgentDefinition["source"] }> = [
|
|
{ path: BUNDLED_AGENTS_DIR, source: "bundled" },
|
|
{ path: resolveGlobalAgentsDirPath(), source: "global" },
|
|
{ path: join(baseCwd, ".cline", "agents"), source: "project" },
|
|
];
|
|
const defs = new Map<string, AgentDefinition>();
|
|
for (const { path, source } of dirs) {
|
|
for (const entry of readMarkdownDir(path, source)) {
|
|
defs.set(entry.name, {
|
|
name: entry.name,
|
|
description: optStr(entry.data.description),
|
|
providerId: optStr(entry.data.providerId),
|
|
modelId: optStr(entry.data.modelId),
|
|
systemPrompt: entry.body,
|
|
cwd: optStr(entry.data.cwd),
|
|
maxIterations: optInt(entry.data.maxIterations),
|
|
source: entry.source,
|
|
});
|
|
}
|
|
}
|
|
return [...defs.values()].sort((a, b) => a.name.localeCompare(b.name));
|
|
}
|
|
|
|
function readSkillDefinitions(baseCwd: string): SkillDefinition[] {
|
|
const dirs: Array<{ path: string; source: SkillDefinition["source"] }> = [
|
|
{ path: BUNDLED_SKILLS_DIR, source: "bundled" },
|
|
{ path: GLOBAL_SKILLS_DIR, source: "global" },
|
|
{ path: join(baseCwd, ".cline", "skills"), source: "project" },
|
|
];
|
|
const defs = new Map<string, SkillDefinition>();
|
|
for (const { path, source } of dirs) {
|
|
for (const entry of readMarkdownDir(path, source)) {
|
|
defs.set(entry.name, {
|
|
name: entry.name,
|
|
description: optStr(entry.data.description),
|
|
content: entry.body,
|
|
source: entry.source,
|
|
});
|
|
}
|
|
}
|
|
return [...defs.values()].sort((a, b) => a.name.localeCompare(b.name));
|
|
}
|
|
|
|
function parentSessionId(ctx: AgentToolContext): string | undefined {
|
|
const id = ctx.metadata?.sessionId;
|
|
return typeof id === "string" && id.trim() ? id.trim() : undefined;
|
|
}
|
|
|
|
function sanitizeConversationId(conversationId: string): string {
|
|
const trimmed = conversationId.trim();
|
|
if (!trimmed || !SAFE_ID_RE.test(trimmed)) {
|
|
throw new Error(`Invalid conversation ID for filesystem use: "${trimmed}"`);
|
|
}
|
|
return trimmed;
|
|
}
|
|
|
|
function handoffsDir(ctx: AgentToolContext): string {
|
|
const conversationId = ctx.conversationId ?? parentSessionId(ctx);
|
|
if (!conversationId) {
|
|
throw new Error("Missing conversation ID for handoff storage");
|
|
}
|
|
const safeId = sanitizeConversationId(conversationId);
|
|
const dir = join(HANDOFFS_DIR, safeId);
|
|
mkdirSync(dir, { recursive: true });
|
|
return dir;
|
|
}
|
|
|
|
function resolveHandoffPath(
|
|
ctx: AgentToolContext,
|
|
relativePath: string,
|
|
): string {
|
|
const handoffPath = validateHandoffRelativePath(relativePath);
|
|
const dir = handoffsDir(ctx);
|
|
const resolved = resolve(dir, handoffPath);
|
|
const pathFromHandoffsDir = relative(dir, resolved);
|
|
if (
|
|
!pathFromHandoffsDir ||
|
|
pathFromHandoffsDir === ".." ||
|
|
pathFromHandoffsDir.startsWith(`..${sep}`) ||
|
|
isAbsolute(pathFromHandoffsDir)
|
|
) {
|
|
throw new Error(`Handoff path escapes directory: ${relativePath}`);
|
|
}
|
|
return resolved;
|
|
}
|
|
|
|
function validateHandoffRelativePath(relativePath: string): string {
|
|
const trimmed = relativePath.trim();
|
|
if (!trimmed) {
|
|
throw new Error("Handoff path must not be empty");
|
|
}
|
|
if (trimmed.length > HANDOFF_PATH_MAX_LENGTH) {
|
|
throw new Error(
|
|
`Handoff path must be ${HANDOFF_PATH_MAX_LENGTH} characters or fewer`,
|
|
);
|
|
}
|
|
if (trimmed.startsWith("/")) {
|
|
throw new Error(`Handoff path must be relative: ${relativePath}`);
|
|
}
|
|
if (!HANDOFF_PATH_ALLOWED_RE.test(trimmed)) {
|
|
throw new Error(
|
|
"Use a relative file path with letters, numbers, '.', '_', '-', or '/'.",
|
|
);
|
|
}
|
|
if (trimmed.split("/").includes("..")) {
|
|
throw new Error(`Handoff path must not contain '..': ${relativePath}`);
|
|
}
|
|
return trimmed;
|
|
}
|
|
|
|
function emitSteer(sessionId: string | undefined, prompt: string): void {
|
|
if (sessionId && prompt.trim()) {
|
|
globalThis.__clinePluginHost?.emitEvent?.("steer_message", {
|
|
sessionId,
|
|
prompt,
|
|
});
|
|
}
|
|
}
|
|
|
|
async function getSessionManager(): Promise<SessionManager> {
|
|
sessionManagerPromise ??= ClineCore.create({
|
|
backendMode: resolveSubagentBackendMode(DEFAULT_BACKEND_MODE),
|
|
}).catch((err) => {
|
|
// Clear the cached promise so subsequent calls can retry.
|
|
sessionManagerPromise = undefined;
|
|
throw err;
|
|
});
|
|
return sessionManagerPromise;
|
|
}
|
|
|
|
function resolveSubagentBackendMode(value: string): SubagentBackendMode {
|
|
switch (value) {
|
|
case "auto":
|
|
case "hub":
|
|
case "local":
|
|
return value;
|
|
default:
|
|
return "auto";
|
|
}
|
|
}
|
|
|
|
function extractLastAssistantText(
|
|
messages: Array<{ role?: string; content?: unknown }>,
|
|
): string {
|
|
for (let i = messages.length - 1; i >= 0; i--) {
|
|
const msg = messages[i];
|
|
if (msg?.role !== "assistant" || !Array.isArray(msg.content)) continue;
|
|
const text = (msg.content as Array<{ type?: string; text?: unknown }>)
|
|
.filter((b) => b?.type === "text" && typeof b.text === "string")
|
|
.map((b) => b.text as string)
|
|
.join("")
|
|
.trim();
|
|
if (text) return text;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
function elapsed(start: number, end = Date.now()): string {
|
|
const s = Math.max(0, Math.floor((end - start) / 1000));
|
|
return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${s % 60}s`;
|
|
}
|
|
|
|
function steerPrompt(subagent: RunningSubagent): string {
|
|
const time = elapsed(subagent.startedAt, subagent.completedAt ?? Date.now());
|
|
const header =
|
|
subagent.status === "completed"
|
|
? `Sub-agent "${subagent.name}" completed (${time}).`
|
|
: `Sub-agent "${subagent.name}" failed (${time}).`;
|
|
const body = subagent.resultText?.trim() || subagent.error?.trim() || "";
|
|
return [header, body, `Session ID: ${subagent.sessionId}`]
|
|
.filter(Boolean)
|
|
.join("\n\n");
|
|
}
|
|
|
|
async function runSubagentTurn(
|
|
subagent: RunningSubagent,
|
|
message: string,
|
|
steer: boolean,
|
|
): Promise<void> {
|
|
try {
|
|
const mgr = await getSessionManager();
|
|
const result = await mgr.send({
|
|
sessionId: subagent.sessionId,
|
|
prompt: message,
|
|
});
|
|
const messages = await mgr.readMessages(subagent.sessionId);
|
|
subagent.status = "completed";
|
|
subagent.finishReason = result?.finishReason;
|
|
subagent.resultText =
|
|
result?.text?.trim() || extractLastAssistantText(messages) || "";
|
|
subagent.error = undefined;
|
|
subagent.completedAt = Date.now();
|
|
} catch (err) {
|
|
subagent.status = "failed";
|
|
subagent.error = err instanceof Error ? err.message : String(err);
|
|
subagent.completedAt = Date.now();
|
|
}
|
|
if (steer) emitSteer(subagent.parentSessionId, steerPrompt(subagent));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Schemas
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const NonEmptyText = z.string().trim().min(1);
|
|
|
|
const HandoffPathInput = z
|
|
.string()
|
|
.trim()
|
|
.min(1)
|
|
.max(240)
|
|
.describe(
|
|
"Relative file path using letters, numbers, '.', '_', '-', or '/'. Must not be absolute or contain '..' segments.",
|
|
);
|
|
|
|
const StartSubagentInput = z
|
|
.object({
|
|
label: NonEmptyText.describe(
|
|
"Short display label for this run, used in status and completion messages.",
|
|
),
|
|
task: NonEmptyText.describe(
|
|
"Primary task for the subagent. This becomes its first user message.",
|
|
),
|
|
preset: NonEmptyText.optional().describe(
|
|
`Optional agent preset name from list_agent_presets. Defaults to "${DEFAULT_AGENT_PRESET}" when omitted.`,
|
|
),
|
|
instructions: NonEmptyText.optional().describe(
|
|
"Extra system instructions appended after the preset prompt. Optional when using a preset.",
|
|
),
|
|
providerId: NonEmptyText.optional().describe(
|
|
"Optional provider override. Defaults to the preset or plugin default.",
|
|
),
|
|
modelId: NonEmptyText.optional().describe(
|
|
"Optional model override. Defaults to the preset or plugin default.",
|
|
),
|
|
workingDirectory: NonEmptyText.optional().describe(
|
|
"Optional working directory, resolved from the plugin base cwd.",
|
|
),
|
|
maxIterations: z
|
|
.number()
|
|
.int()
|
|
.min(1)
|
|
.optional()
|
|
.describe("Optional hard limit for the subagent turn loop."),
|
|
notifyParent: z
|
|
.boolean()
|
|
.optional()
|
|
.describe(
|
|
"When true or omitted, send the final outcome back to the parent session.",
|
|
),
|
|
})
|
|
.strict();
|
|
|
|
const MessageSubagentInput = z
|
|
.object({
|
|
sessionId: NonEmptyText.describe("Existing subagent session ID."),
|
|
prompt: NonEmptyText.describe(
|
|
"Follow-up user message to send to the subagent.",
|
|
),
|
|
notifyParent: z
|
|
.boolean()
|
|
.optional()
|
|
.describe(
|
|
"When true or omitted, send the final outcome back to the parent session.",
|
|
),
|
|
})
|
|
.strict();
|
|
|
|
const GetSubagentInput = z
|
|
.object({
|
|
sessionId: NonEmptyText.describe("Subagent session ID."),
|
|
})
|
|
.strict();
|
|
|
|
const SaveHandoffInput = z
|
|
.object({
|
|
path: HandoffPathInput.describe(
|
|
"Relative path inside the conversation handoff store, for example 'research/notes.md'.",
|
|
),
|
|
content: z
|
|
.string()
|
|
.describe(
|
|
"Text content to store for later retrieval by this conversation's agents.",
|
|
),
|
|
})
|
|
.strict();
|
|
|
|
const ReadHandoffInput = z
|
|
.object({
|
|
path: HandoffPathInput.describe(
|
|
"Relative path inside the conversation handoff store.",
|
|
),
|
|
})
|
|
.strict();
|
|
|
|
const GetSkillInput = z
|
|
.object({
|
|
name: NonEmptyText.describe("Skill name from list_skills."),
|
|
})
|
|
.strict();
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Plugin
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const plugin: AgentPlugin = {
|
|
name: "portable-subagents",
|
|
manifest: { capabilities: ["tools"] },
|
|
|
|
setup(api, ctx) {
|
|
const logger = ctx.logger;
|
|
logger?.log("portable-subagents plugin setup", {
|
|
sessionId: ctx.session?.sessionId,
|
|
defaultPreset: DEFAULT_AGENT_PRESET,
|
|
backendMode: DEFAULT_BACKEND_MODE,
|
|
workspaceRoot: ctx.workspaceInfo?.rootPath,
|
|
});
|
|
|
|
// -- start_subagent: Start a new subagent session --
|
|
api.registerTool(
|
|
toRegisteredTool(
|
|
createTool({
|
|
name: "start_subagent",
|
|
description: `Start a background subagent run and return its session ID immediately. Prefer a preset from list_agent_presets; when omitted, this tool uses the bundled "${DEFAULT_AGENT_PRESET}" preset automatically. Use get_subagent to poll, or keep notifyParent enabled to have the result pushed back into the parent session.`,
|
|
inputSchema: StartSubagentInput,
|
|
timeoutMs: 60_000,
|
|
retryable: false,
|
|
async execute(input, ctx) {
|
|
const mgr = await getSessionManager();
|
|
const baseCwd = envOr("CLINE_SUBAGENT_CWD", process.cwd());
|
|
const defs = readAgentDefinitions(baseCwd);
|
|
const presetName = input.preset ?? DEFAULT_AGENT_PRESET;
|
|
const def = defs.find((d) => d.name === presetName);
|
|
if (presetName && !def && !input.instructions?.trim()) {
|
|
throw new Error(`Unknown agent preset: ${presetName}`);
|
|
}
|
|
|
|
const cwd = resolve(
|
|
baseCwd,
|
|
input.workingDirectory ?? def?.cwd ?? ".",
|
|
);
|
|
const providerId =
|
|
input.providerId ?? def?.providerId ?? DEFAULT_PROVIDER_ID;
|
|
const modelId = input.modelId ?? def?.modelId ?? DEFAULT_MODEL_ID;
|
|
const prompt = [
|
|
def?.systemPrompt?.trim(),
|
|
input.instructions?.trim(),
|
|
]
|
|
.filter(Boolean)
|
|
.join("\n\n");
|
|
if (!prompt) {
|
|
throw new Error(
|
|
`Subagent "${input.label}" needs instructions. Provide "instructions" or use an available preset such as "${DEFAULT_AGENT_PRESET}".`,
|
|
);
|
|
}
|
|
|
|
const { sessionId } = await mgr.start({
|
|
config: {
|
|
providerId,
|
|
modelId,
|
|
cwd,
|
|
workspaceRoot: cwd,
|
|
enableTools: true,
|
|
enableSpawnAgent: false,
|
|
enableAgentTeams: false,
|
|
pluginPaths: [],
|
|
systemPrompt: prompt,
|
|
maxIterations: input.maxIterations ?? def?.maxIterations,
|
|
},
|
|
interactive: false,
|
|
});
|
|
|
|
const subagent: RunningSubagent = {
|
|
sessionId,
|
|
parentSessionId: parentSessionId(ctx),
|
|
name: input.label,
|
|
task: input.task,
|
|
agent: input.preset,
|
|
startedAt: Date.now(),
|
|
status: "running",
|
|
};
|
|
subagents.set(sessionId, subagent);
|
|
logger?.log("Started subagent", {
|
|
sessionId,
|
|
toolName: "start_subagent",
|
|
label: input.label,
|
|
preset: def?.name ?? input.preset,
|
|
providerId,
|
|
modelId,
|
|
});
|
|
void runSubagentTurn(
|
|
subagent,
|
|
input.task,
|
|
input.notifyParent !== false,
|
|
);
|
|
|
|
return {
|
|
status: "started",
|
|
sessionId,
|
|
label: subagent.name,
|
|
preset: def?.name ?? input.preset,
|
|
task: subagent.task,
|
|
};
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
|
|
// -- list_agent_presets: Show available agent definitions --
|
|
api.registerTool(
|
|
toRegisteredTool(
|
|
createTool({
|
|
name: "list_agent_presets",
|
|
description:
|
|
"List the available subagent presets, including bundled, global, and project-level definitions.",
|
|
inputSchema: z.object({}).strict(),
|
|
async execute(_input, _ctx) {
|
|
const baseCwd = envOr("CLINE_SUBAGENT_CWD", process.cwd());
|
|
const agents = readAgentDefinitions(baseCwd).map((a) => ({
|
|
name: a.name,
|
|
description: a.description,
|
|
providerId: a.providerId ?? DEFAULT_PROVIDER_ID,
|
|
modelId: a.modelId ?? DEFAULT_MODEL_ID,
|
|
source: a.source,
|
|
}));
|
|
return {
|
|
agents,
|
|
text: agents.length
|
|
? agents
|
|
.map(
|
|
(a) =>
|
|
`- ${a.name} [${a.source}] (${a.providerId}/${a.modelId})${a.description ? `: ${a.description}` : ""}`,
|
|
)
|
|
.join("\n")
|
|
: "No agent definitions found.",
|
|
};
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
|
|
// -- message_subagent: Send follow-up to an existing session --
|
|
api.registerTool(
|
|
toRegisteredTool(
|
|
createTool({
|
|
name: "message_subagent",
|
|
description:
|
|
"Send a follow-up message to an existing subagent session and return immediately.",
|
|
inputSchema: MessageSubagentInput,
|
|
timeoutMs: 60_000,
|
|
retryable: false,
|
|
async execute(input, ctx) {
|
|
const mgr = await getSessionManager();
|
|
const record = await mgr.get(input.sessionId);
|
|
if (!record) {
|
|
throw new Error(`Unknown session: ${input.sessionId}`);
|
|
}
|
|
|
|
const subagent: RunningSubagent = subagents.get(
|
|
input.sessionId,
|
|
) ?? {
|
|
sessionId: input.sessionId,
|
|
parentSessionId: parentSessionId(ctx),
|
|
name: input.sessionId,
|
|
task: input.prompt,
|
|
startedAt: Date.now(),
|
|
status: "running",
|
|
};
|
|
subagent.parentSessionId = parentSessionId(ctx);
|
|
subagent.task = input.prompt;
|
|
subagent.status = "running";
|
|
subagent.error = undefined;
|
|
subagents.set(subagent.sessionId, subagent);
|
|
|
|
logger?.log("Queued subagent follow-up", {
|
|
sessionId: subagent.sessionId,
|
|
toolName: "message_subagent",
|
|
label: subagent.name,
|
|
});
|
|
void runSubagentTurn(
|
|
subagent,
|
|
input.prompt,
|
|
input.notifyParent !== false,
|
|
);
|
|
return {
|
|
status: "started",
|
|
sessionId: subagent.sessionId,
|
|
label: subagent.name,
|
|
task: subagent.task,
|
|
};
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
|
|
// -- get_subagent: Check subagent result --
|
|
api.registerTool(
|
|
toRegisteredTool(
|
|
createTool({
|
|
name: "get_subagent",
|
|
description:
|
|
"Get the latest status, output, and error details for a subagent session.",
|
|
inputSchema: GetSubagentInput,
|
|
async execute(input, _ctx) {
|
|
const subagent = subagents.get(input.sessionId);
|
|
if (!subagent) {
|
|
return {
|
|
status: "unknown",
|
|
sessionId: input.sessionId,
|
|
text: `No tracked session: ${input.sessionId}`,
|
|
};
|
|
}
|
|
return {
|
|
status: subagent.status,
|
|
sessionId: subagent.sessionId,
|
|
label: subagent.name,
|
|
task: subagent.task,
|
|
finishReason: subagent.finishReason,
|
|
error: subagent.error,
|
|
text:
|
|
subagent.resultText ??
|
|
(subagent.status === "running" ? "Still running." : ""),
|
|
};
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
|
|
// -- save_handoff: Persist a conversation-scoped handoff file --
|
|
api.registerTool(
|
|
toRegisteredTool(
|
|
createTool({
|
|
name: "save_handoff",
|
|
description:
|
|
"Save text into the conversation handoff store so other agents in this conversation can read it later.",
|
|
inputSchema: SaveHandoffInput,
|
|
async execute(input, ctx) {
|
|
const filePath = resolveHandoffPath(ctx, input.path);
|
|
mkdirSync(dirname(filePath), { recursive: true });
|
|
writeFileSync(filePath, input.content, "utf8");
|
|
return { path: filePath, handoffPath: input.path };
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
|
|
// -- read_handoff: Read a conversation-scoped handoff file --
|
|
api.registerTool(
|
|
toRegisteredTool(
|
|
createTool({
|
|
name: "read_handoff",
|
|
description: "Read text from the conversation handoff store.",
|
|
inputSchema: ReadHandoffInput,
|
|
async execute(input, ctx) {
|
|
const filePath = resolveHandoffPath(ctx, input.path);
|
|
if (!existsSync(filePath)) {
|
|
throw new Error(`Handoff not found: ${input.path}`);
|
|
}
|
|
return {
|
|
path: filePath,
|
|
handoffPath: input.path,
|
|
content: readFileSync(filePath, "utf8"),
|
|
};
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
|
|
// -- list_skills: Show available skill definitions --
|
|
api.registerTool(
|
|
toRegisteredTool(
|
|
createTool({
|
|
name: "list_skills",
|
|
description:
|
|
"List the available skill definitions from bundled, global, and project-level directories.",
|
|
inputSchema: z.object({}).strict(),
|
|
async execute(_input, _ctx) {
|
|
const baseCwd = envOr("CLINE_SUBAGENT_CWD", process.cwd());
|
|
const skills = readSkillDefinitions(baseCwd);
|
|
return {
|
|
skills: skills.map((s) => ({
|
|
name: s.name,
|
|
description: s.description,
|
|
source: s.source,
|
|
})),
|
|
text: skills.length
|
|
? skills
|
|
.map(
|
|
(s) =>
|
|
`- ${s.name} [${s.source}]${s.description ? `: ${s.description}` : ""}`,
|
|
)
|
|
.join("\n")
|
|
: "No skill definitions found.",
|
|
};
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
|
|
// -- get_skill: Load a skill's instructions --
|
|
api.registerTool(
|
|
toRegisteredTool(
|
|
createTool({
|
|
name: "get_skill",
|
|
description:
|
|
"Get a skill by name, including the instructions that should be followed for that specialization.",
|
|
inputSchema: GetSkillInput,
|
|
async execute(input, _ctx) {
|
|
const baseCwd = envOr("CLINE_SUBAGENT_CWD", process.cwd());
|
|
const skills = readSkillDefinitions(baseCwd);
|
|
const skill = skills.find((s) => s.name === input.name);
|
|
if (!skill) {
|
|
const available = skills.map((s) => s.name).join(", ");
|
|
throw new Error(
|
|
`Unknown skill: "${input.name}". Available: ${available || "none"}`,
|
|
);
|
|
}
|
|
return {
|
|
name: skill.name,
|
|
description: skill.description,
|
|
source: skill.source,
|
|
instructions: skill.content,
|
|
};
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
},
|
|
};
|
|
|
|
export { plugin };
|
|
export default plugin;
|