332 lines
12 KiB
TypeScript
332 lines
12 KiB
TypeScript
import { mkdir, rename, stat } from 'node:fs/promises';
|
|
import path from 'node:path';
|
|
import { atomicWriteJson, atomicWriteText } from '../../coding-projects/atomic-json';
|
|
import { validateSessionKey } from '../../coding-projects/conversation-store';
|
|
import { resolveBundledCodingPluginRootPaths } from '../../coding-plugins/manifest';
|
|
import type { PiProviderSelection } from './provider-config';
|
|
import type { PiManagedInputRevision } from './managed-input-revision';
|
|
import type { EffectivePluginSnapshot } from '../../coding-plugins/effective-resolver';
|
|
|
|
const MANAGED_SEGMENT_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
|
|
|
|
export interface PiSkillEntry {
|
|
id: string;
|
|
entryPath: string;
|
|
packageRoot?: string;
|
|
}
|
|
|
|
export const MAKELORE_DEFAULT_LANGUAGE_PROMPT = `你正在 Makelore 中工作，产品默认服务中文用户。
|
|
|
|
语言要求：
|
|
- 默认使用简体中文进行所有自然语言表达，包括可见的思考过程、进度说明、工具调用说明、提问、总结和最终回复。
|
|
- 代码、命令、标识符、文件路径、日志、错误原文，以及为保证准确性必须保留原文的引用，可以使用其原始语言。
|
|
- 只有当用户或项目智能体的自定义系统指令明确要求其他语言时，才改用对应语言。`;
|
|
|
|
export interface BundledCodingSkillsPathInput {
|
|
isPackaged: boolean;
|
|
resourcesPath: string;
|
|
appPath: string;
|
|
}
|
|
|
|
export interface PiManagedPaths {
|
|
rootDir: string;
|
|
configDir: string;
|
|
modelsFile: string;
|
|
sessionsDir: string;
|
|
promptsDir: string;
|
|
extensionsDir: string;
|
|
logsDir: string;
|
|
trashDir: string;
|
|
}
|
|
|
|
export interface MaterializePiAgentResourcesOptions {
|
|
userDataDir: string;
|
|
projectId: string;
|
|
agentId: string;
|
|
prompt: string;
|
|
skillEntries: readonly PiSkillEntry[];
|
|
catalogRevision: number;
|
|
bundledSkillsDir: string;
|
|
/** Main-owned installed package roots for effective Marketplace Skills. */
|
|
skillRoots?: readonly string[];
|
|
/** The exact resolver output for this worker generation. */
|
|
effectiveSnapshot?: EffectivePluginSnapshot;
|
|
revision: PiManagedInputRevision;
|
|
}
|
|
|
|
export interface PiAgentResourceManifest {
|
|
schemaVersion: 1;
|
|
projectId: string;
|
|
agentId: string;
|
|
promptFile: string;
|
|
languagePromptFile: string;
|
|
skillIds: string[];
|
|
skillEntries: PiSkillEntry[];
|
|
catalogRevision: number;
|
|
revision: PiManagedInputRevision;
|
|
effectivePluginSnapshot?: EffectivePluginSnapshot;
|
|
}
|
|
|
|
export interface PiAgentResourceSnapshot {
|
|
paths: PiManagedPaths;
|
|
projectSessionsDir: string;
|
|
promptPath: string;
|
|
languagePromptPath: string;
|
|
manifestPath: string;
|
|
skillIds: string[];
|
|
skillEntries: PiSkillEntry[];
|
|
skillPaths: string[];
|
|
catalogRevision: number;
|
|
revision: PiManagedInputRevision;
|
|
effectivePluginSnapshot?: EffectivePluginSnapshot;
|
|
summary: {
|
|
projectId: string;
|
|
agentId: string;
|
|
skillIds: string[];
|
|
skillEntries: PiSkillEntry[];
|
|
catalogRevision: number;
|
|
revision: PiManagedInputRevision;
|
|
effectivePluginSnapshot?: EffectivePluginSnapshot;
|
|
};
|
|
}
|
|
|
|
function managedSegment(value: string, name: string): string {
|
|
const normalized = value.trim();
|
|
if (!MANAGED_SEGMENT_PATTERN.test(normalized)) {
|
|
throw new Error(`${name} is not a valid managed resource segment`);
|
|
}
|
|
return normalized;
|
|
}
|
|
|
|
export function resolveBundledCodingSkillsDir(input: BundledCodingSkillsPathInput): string {
|
|
return input.isPackaged
|
|
? path.join(input.resourcesPath, 'resources', 'coding-skills')
|
|
: path.join(input.appPath, 'resources', 'coding-skills');
|
|
}
|
|
|
|
export function getPiManagedPaths(userDataDir: string): PiManagedPaths {
|
|
const rootDir = path.join(path.resolve(userDataDir), 'coding-runtime', 'pi');
|
|
const configDir = path.join(rootDir, 'config');
|
|
return {
|
|
rootDir,
|
|
configDir,
|
|
modelsFile: path.join(configDir, 'models.json'),
|
|
sessionsDir: path.join(rootDir, 'sessions'),
|
|
promptsDir: path.join(rootDir, 'prompts'),
|
|
extensionsDir: path.join(rootDir, 'extensions'),
|
|
logsDir: path.join(rootDir, 'logs'),
|
|
trashDir: path.join(rootDir, 'trash'),
|
|
};
|
|
}
|
|
|
|
export async function ensurePiManagedPaths(userDataDir: string): Promise<PiManagedPaths> {
|
|
const paths = getPiManagedPaths(userDataDir);
|
|
await Promise.all([
|
|
mkdir(paths.configDir, { recursive: true }),
|
|
mkdir(paths.sessionsDir, { recursive: true }),
|
|
mkdir(paths.promptsDir, { recursive: true }),
|
|
mkdir(paths.extensionsDir, { recursive: true }),
|
|
mkdir(paths.logsDir, { recursive: true }),
|
|
mkdir(paths.trashDir, { recursive: true }),
|
|
]);
|
|
return paths;
|
|
}
|
|
|
|
export async function archivePiConversationSession(input: {
|
|
userDataDir: string;
|
|
projectId: string;
|
|
sessionKey: string;
|
|
}): Promise<string | null> {
|
|
const projectId = managedSegment(input.projectId, 'Project id');
|
|
const sessionKey = validateSessionKey(input.sessionKey);
|
|
const paths = getPiManagedPaths(input.userDataDir);
|
|
const source = path.join(paths.sessionsDir, projectId, `${sessionKey}.jsonl`);
|
|
const targetDirectory = path.join(paths.trashDir, projectId);
|
|
const target = path.join(targetDirectory, `${sessionKey}.jsonl`);
|
|
await mkdir(targetDirectory, { recursive: true });
|
|
try {
|
|
await rename(source, target);
|
|
return target;
|
|
} catch (error) {
|
|
if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
|
|
const alreadyArchived = await stat(target).catch((targetError: NodeJS.ErrnoException) => {
|
|
if (targetError.code === 'ENOENT') return null;
|
|
throw targetError;
|
|
});
|
|
return alreadyArchived?.isFile() ? target : null;
|
|
}
|
|
}
|
|
|
|
function normalizeSkillEntries(skillEntries: readonly PiSkillEntry[]): PiSkillEntry[] {
|
|
const result: PiSkillEntry[] = [];
|
|
const seen = new Set<string>();
|
|
for (const rawEntry of skillEntries) {
|
|
if (!rawEntry || typeof rawEntry.id !== 'string' || typeof rawEntry.entryPath !== 'string') {
|
|
throw new Error('Effective coding Skill entry is invalid');
|
|
}
|
|
const skillId = rawEntry.id.trim();
|
|
const entryPath = rawEntry.entryPath.trim().replaceAll('\\', '/');
|
|
if (!skillId || !entryPath) throw new Error('Effective coding Skill entry is invalid');
|
|
const packageRoot = typeof rawEntry.packageRoot === 'string'
|
|
? rawEntry.packageRoot.trim()
|
|
: undefined;
|
|
if (rawEntry.packageRoot !== undefined && !packageRoot) {
|
|
throw new Error('Effective coding Skill package root is invalid');
|
|
}
|
|
if (entryPath.startsWith('/') || /^[A-Za-z]:\//u.test(entryPath)
|
|
|| /^[A-Za-z][A-Za-z0-9+.-]*:/u.test(entryPath)) {
|
|
throw new Error(`Effective coding Skill entry path must be relative: ${entryPath}`);
|
|
}
|
|
const relative = path.posix.normalize(entryPath);
|
|
if (!relative || relative === '.' || relative === '..' || relative.startsWith('../')) {
|
|
throw new Error(`Effective coding Skill entry path escapes its package: ${entryPath}`);
|
|
}
|
|
if (seen.has(skillId)) continue;
|
|
seen.add(skillId);
|
|
result.push({
|
|
id: skillId,
|
|
entryPath: relative,
|
|
...(packageRoot ? { packageRoot: path.resolve(packageRoot) } : {}),
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function catalogRevision(value: number): number {
|
|
if (!Number.isSafeInteger(value) || value < 0) {
|
|
throw new Error('Catalog revision must be a non-negative safe integer');
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function pathWithin(root: string, entryPath: string): string | null {
|
|
const resolvedRoot = path.resolve(root);
|
|
const resolved = path.resolve(resolvedRoot, ...entryPath.split('/'));
|
|
const relative = path.relative(resolvedRoot, resolved);
|
|
if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
|
|
return null;
|
|
}
|
|
return resolved;
|
|
}
|
|
|
|
async function resolveSkillEntryPath(
|
|
bundledSkillsDir: string,
|
|
entry: PiSkillEntry,
|
|
skillRoots: readonly string[] = [],
|
|
): Promise<string> {
|
|
const roots = entry.packageRoot
|
|
? [path.resolve(entry.packageRoot)]
|
|
: [
|
|
path.resolve(bundledSkillsDir),
|
|
...resolveBundledCodingPluginRootPaths(path.join(
|
|
path.dirname(path.resolve(bundledSkillsDir)),
|
|
'coding-plugins',
|
|
)),
|
|
...skillRoots.map((root) => path.resolve(root)),
|
|
];
|
|
for (const root of roots) {
|
|
const candidate = pathWithin(root, entry.entryPath);
|
|
if (!candidate) continue;
|
|
try {
|
|
const metadata = await stat(candidate);
|
|
if (metadata.isFile()) return candidate;
|
|
} catch (error) {
|
|
if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
|
|
}
|
|
}
|
|
throw new Error(`Bundled coding Skill entry is not a file: ${entry.entryPath}`);
|
|
}
|
|
|
|
export async function resolveExplicitCodingSkillPaths(
|
|
bundledSkillsDir: string,
|
|
skillEntries: readonly PiSkillEntry[],
|
|
skillRoots: readonly string[] = [],
|
|
): Promise<{ skillIds: string[]; skillEntries: PiSkillEntry[]; skillPaths: string[] }> {
|
|
const normalizedEntries = normalizeSkillEntries(skillEntries);
|
|
const skillPaths = await Promise.all(normalizedEntries.map((entry) => (
|
|
resolveSkillEntryPath(bundledSkillsDir, entry, skillRoots)
|
|
)));
|
|
return {
|
|
skillIds: normalizedEntries.map(({ id }) => id),
|
|
skillEntries: normalizedEntries,
|
|
skillPaths,
|
|
};
|
|
}
|
|
|
|
export async function materializePiAgentResources(
|
|
options: MaterializePiAgentResourcesOptions,
|
|
): Promise<PiAgentResourceSnapshot> {
|
|
const projectId = managedSegment(options.projectId, 'Project id');
|
|
const agentId = managedSegment(options.agentId, 'Agent id');
|
|
const paths = await ensurePiManagedPaths(options.userDataDir);
|
|
const projectSessionsDir = path.join(paths.sessionsDir, projectId);
|
|
const projectPromptsDir = path.join(paths.promptsDir, projectId);
|
|
await Promise.all([
|
|
mkdir(projectSessionsDir, { recursive: true }),
|
|
mkdir(projectPromptsDir, { recursive: true }),
|
|
]);
|
|
const { skillIds, skillEntries, skillPaths } = await resolveExplicitCodingSkillPaths(
|
|
options.bundledSkillsDir,
|
|
options.skillEntries,
|
|
options.skillRoots,
|
|
);
|
|
const resolvedCatalogRevision = catalogRevision(options.catalogRevision);
|
|
const promptPath = path.join(projectPromptsDir, `${agentId}.md`);
|
|
const languagePromptPath = path.join(projectPromptsDir, `${agentId}.language.md`);
|
|
const manifestPath = path.join(projectPromptsDir, `${agentId}.manifest.json`);
|
|
const manifest: PiAgentResourceManifest = {
|
|
schemaVersion: 1,
|
|
projectId,
|
|
agentId,
|
|
promptFile: path.basename(promptPath),
|
|
languagePromptFile: path.basename(languagePromptPath),
|
|
skillIds: [...skillIds],
|
|
skillEntries: structuredClone(skillEntries),
|
|
catalogRevision: resolvedCatalogRevision,
|
|
revision: { ...options.revision },
|
|
...(options.effectiveSnapshot ? { effectivePluginSnapshot: structuredClone(options.effectiveSnapshot) } : {}),
|
|
};
|
|
await Promise.all([
|
|
atomicWriteText(promptPath, options.prompt),
|
|
atomicWriteText(languagePromptPath, MAKELORE_DEFAULT_LANGUAGE_PROMPT),
|
|
]);
|
|
await atomicWriteJson(manifestPath, manifest);
|
|
return {
|
|
paths,
|
|
projectSessionsDir,
|
|
promptPath,
|
|
languagePromptPath,
|
|
manifestPath,
|
|
skillIds: [...skillIds],
|
|
skillEntries: structuredClone(skillEntries),
|
|
skillPaths,
|
|
catalogRevision: resolvedCatalogRevision,
|
|
revision: { ...options.revision },
|
|
...(options.effectiveSnapshot ? { effectivePluginSnapshot: structuredClone(options.effectiveSnapshot) } : {}),
|
|
summary: {
|
|
projectId,
|
|
agentId,
|
|
skillIds: [...skillIds],
|
|
skillEntries: structuredClone(skillEntries),
|
|
catalogRevision: resolvedCatalogRevision,
|
|
revision: { ...options.revision },
|
|
...(options.effectiveSnapshot ? { effectivePluginSnapshot: structuredClone(options.effectiveSnapshot) } : {}),
|
|
},
|
|
};
|
|
}
|
|
|
|
export function buildPiManagedInputArgs(
|
|
selection: PiProviderSelection,
|
|
resources: PiAgentResourceSnapshot,
|
|
): string[] {
|
|
const args = [
|
|
'--provider', selection.runtimeProviderId,
|
|
'--model', selection.modelId,
|
|
'--thinking', selection.thinkingLevel,
|
|
'--system-prompt', resources.promptPath,
|
|
'--append-system-prompt', resources.languagePromptPath,
|
|
];
|
|
for (const skillPath of resources.skillPaths) args.push('--skill', skillPath);
|
|
return args;
|
|
}
|