pi-feats 0.1.3 → 0.1.5

package/extensions/api-server/profile-store.ts

@@ -1,14 +1,16 @@
 import { existsSync } from "node:fs";
-import { copyFile, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, readFile, readlink, readdir, rm, symlink, writeFile } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
 import { ensureProfileSandbox } from "../lib/profile-sandbox.ts";
+import { BUILTIN_TOOLS, activeBuiltinTools, updatedBuiltinTools } from "../lib/builtin-tools.ts";
 
-export const BUILTIN_TOOLS = ["read", "bash", "powershell", "edit", "write", "grep", "find", "ls"];
+export { BUILTIN_TOOLS } from "../lib/builtin-tools.ts";
 export const RESOURCE_KINDS = ["tools", "skills", "extensions"] as const;
 export type ResourceKind = typeof RESOURCE_KINDS[number];
 type PolicyKey = "enabledTools" | "enabledSkills" | "enabledProfileSkills" | "enabledExtensions";
 type SkillSources = { shared?: boolean; profile?: boolean };
-type ProfilePolicy = Partial<Record<PolicyKey, string[]>> & { skillSources?: SkillSources };
+type SkillResourceSource = "shared" | "profile" | "package";
+type ProfilePolicy = Partial<Record<PolicyKey, string[]>> & { skillSources?: SkillSources; contextMemory?: { mode: "file"; target: "profile" | "identity" } | { mode: "handler"; handler: string } };
 export type ProfileSettings = Record<string, unknown> & { profile?: ProfilePolicy; sandbox?: boolean };
 export type Resource = { name: string; kind: ResourceKind; path?: string; source: "builtin" | "shared" | "profile" | "extension" | "package"; package?: string; enabled: boolean; protected?: boolean };
 export type Package = { name: string; version?: string; description?: string; enabled: boolean; installed: boolean };
@@ -22,12 +24,24 @@ const policyKey: Record<ResourceKind, PolicyKey> = {
 const protectedExtensions = new Set(["profiles", "api-server"]);
 
 export class ProfileStore {
-  private readonly extensionTools = new Set<string>();
+  private readonly extensionTools = new Map<string, Set<string>>();
+  readonly agentDir: string;
 
-  constructor(readonly agentDir: string) {}
+  constructor(agentDir: string) { this.agentDir = agentDir; }
 
-  registerExtensionTools(names: Iterable<string>): void {
-    for (const name of names) if (name && !BUILTIN_TOOLS.includes(name)) this.extensionTools.add(name);
+  registerExtensionTools(profile: string, names: Iterable<string>): void {
+    const tools = this.extensionTools.get(profile) ?? new Set<string>();
+    for (const name of names) if (name && !(BUILTIN_TOOLS as readonly string[]).includes(name)) tools.add(name);
+    this.extensionTools.set(profile, tools);
+  }
+
+  extensionToolNames(profile: string): Iterable<string> {
+    return this.extensionTools.get(profile) ?? [];
+  }
+
+  clearExtensionTools(profile?: string): void {
+    if (profile) this.extensionTools.delete(profile);
+    else this.extensionTools.clear();
   }
 
   private profilesDir(): string { return join(this.agentDir, "profiles"); }
@@ -37,6 +51,13 @@ export class ProfileStore {
     return join(this.profilesDir(), name);
   }
   private settingsPath(name: string): string { return join(this.directory(name), "settings.json"); }
+  private async linkSharedModels(name: string): Promise<void> {
+    if (name === "default") return;
+    const source = join(this.agentDir, "models.json"), target = join(this.directory(name), "models.json");
+    try { if (resolve(this.directory(name), await readlink(target)) === source) return; } catch { /* Missing or non-symlink target must be replaced. */ }
+    await rm(target, { force: true });
+    if (existsSync(source)) await symlink(source, target);
+  }
   private skillSources(name: string, settings: ProfileSettings): Required<SkillSources> {
     if (name === "default") return { shared: true, profile: false };
     return { shared: settings.profile?.skillSources?.shared !== false, profile: settings.profile?.skillSources?.profile === true };
@@ -50,6 +71,7 @@ export class ProfileStore {
     try {
       const value = JSON.parse(await readFile(path, "utf8")) as unknown;
       if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("settings.json must contain an object");
+      await this.linkSharedModels(name);
       return value as ProfileSettings;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === "ENOENT" && name === "default") return {};
@@ -94,19 +116,32 @@ export class ProfileStore {
   private enabled(settings: ProfileSettings, kind: ResourceKind, name: string, path?: string): boolean {
     const values = settings.profile?.[policyKey[kind]];
     if (values) return values.includes("*") || values.includes(name);
+    if (kind === "tools" && (BUILTIN_TOOLS as readonly string[]).includes(name)) return activeBuiltinTools(settings).includes(name);
     const configured = settings[kind];
     const exclusions = Array.isArray(configured) ? configured.filter((value): value is string => typeof value === "string" && value.startsWith("!")) : [];
     return !path || !exclusions.includes(`!${path}`);
   }
 
-  private async skillResources(profile: string, settings: ProfileSettings): Promise<Resource[]> {
+  private async packageSkillResources(settings: ProfileSettings): Promise<Resource[]> {
+    const resources: Resource[] = [];
+    for (const pkg of await this.configuredPackages(settings)) {
+      for (const entry of Array.isArray(pkg.manifest?.pi?.skills) ? pkg.manifest.pi.skills : []) {
+        if (typeof entry !== "string") continue;
+        for (const skill of await this.skillNames(join(pkg.base, entry))) resources.push({ name: skill.name, kind: "skills", path: skill.path, source: "package", package: pkg.name, enabled: this.skillEnabled(settings, "package", skill.name) });
+      }
+    }
+    return resources;
+  }
+
+  private async skillResources(profile: string, settings: ProfileSettings, runtimeSettings: ProfileSettings = settings): Promise<Resource[]> {
     const sources = this.skillSources(profile, settings);
     const entries = await Promise.all((["profile", "shared"] as const).filter((source) => sources[source]).map(async (source) => ({ source, entries: await this.skillNames(this.skillBase(profile, source)) })));
-    return entries.flatMap(({ source, entries }) => entries.map(({ name, path }) => ({ name, kind: "skills" as const, path, source, enabled: this.skillEnabled(settings, source, name) })));
+    const local = entries.flatMap(({ source, entries }) => entries.map(({ name, path }) => ({ name, kind: "skills" as const, path, source, enabled: this.skillEnabled(settings, source, name) })));
+    return [...local, ...(sources.shared ? await this.packageSkillResources(runtimeSettings) : [])];
   }
 
-  private skillEnabled(settings: ProfileSettings, source: "shared" | "profile", name: string): boolean {
-    const values = settings.profile?.[source === "shared" ? "enabledSkills" : "enabledProfileSkills"];
+  private skillEnabled(settings: ProfileSettings, source: SkillResourceSource, name: string): boolean {
+    const values = settings.profile?.[source === "profile" ? "enabledProfileSkills" : "enabledSkills"];
     return !values || values.includes("*") || values.includes(name);
   }
 
@@ -120,12 +155,12 @@ export class ProfileStore {
     return join(this.agentDir, "git", remote);
   }
 
-  private async configuredPackages(settings: ProfileSettings): Promise<Array<{ source: string; base: string; name: string; manifest?: { version?: string; description?: string; pi?: { extensions?: unknown } } }>> {
+  private async configuredPackages(settings: ProfileSettings): Promise<Array<{ source: string; base: string; name: string; manifest?: { version?: string; description?: string; pi?: { extensions?: unknown; skills?: unknown } } }>> {
     const sources = Array.isArray(settings.packages) ? settings.packages.filter((value): value is string => typeof value === "string") : [];
-    const packages: Array<{ source: string; base: string; name: string; manifest?: { version?: string; description?: string; pi?: { extensions?: unknown } } }> = [];
+    const packages: Array<{ source: string; base: string; name: string; manifest?: { version?: string; description?: string; pi?: { extensions?: unknown; skills?: unknown } } }> = [];
     for (const source of sources) {
       const base = this.packageBase(source); if (!base) continue;
-      try { const manifest = JSON.parse(await readFile(join(base, "package.json"), "utf8")) as { name?: string; version?: string; description?: string; pi?: { extensions?: unknown } }; packages.push({ source, base, name: manifest.name ?? source, manifest }); }
+      try { const manifest = JSON.parse(await readFile(join(base, "package.json"), "utf8")) as { name?: string; version?: string; description?: string; pi?: { extensions?: unknown; skills?: unknown } }; packages.push({ source, base, name: manifest.name ?? source, manifest }); }
       catch { packages.push({ source, base, name: source.replace(/^npm:/, "") }); }
     }
     return packages;
@@ -159,8 +194,8 @@ export class ProfileStore {
     const sources = new Map<string, string>(), tools = [...names];
     for (const extension of await this.packageExtensions(settings)) try {
       const source = await readFile(extension.path, "utf8");
-      for (const tool of tools) if (source.includes(`"${tool}"`) || source.includes(`'${tool}'`) || source.includes(`\`${tool}\``)) sources.set(tool, extension.package);
-      for (const block of source.matchAll(/TOOL_NAMES[^=]*=\s*\{([\s\S]*?)\}/g)) for (const name of block[1].matchAll(/:\s*["']([A-Za-z][A-Za-z0-9_-]{0,63})["']/g)) sources.set(name[1], extension.package);
+      for (const tool of tools) if (!(BUILTIN_TOOLS as readonly string[]).includes(tool) && (source.includes(`"${tool}"`) || source.includes(`'${tool}'`) || source.includes(`\`${tool}\``))) sources.set(tool, extension.package);
+      for (const block of source.matchAll(/TOOL_NAMES[^=]*=\s*\{([\s\S]*?)\}/g)) for (const name of block[1].matchAll(/:\s*["']([A-Za-z][A-Za-z0-9_-]{0,63})["']/g)) if (!(BUILTIN_TOOLS as readonly string[]).includes(name[1])) sources.set(name[1], extension.package);
     } catch {}
     return sources;
   }
@@ -168,23 +203,25 @@ export class ProfileStore {
   async resources(profile: string, kind: ResourceKind): Promise<Resource[]> {
     const settings = await this.readSettings(profile);
     const runtimeSettings = profile === "default" ? settings : await this.readSettings("default");
-    if (kind === "skills") return this.skillResources(profile, settings);
+    if (kind === "skills") return this.skillResources(profile, settings, runtimeSettings);
     if (kind === "tools") {
-      const sources = await this.packageToolSources(runtimeSettings, this.extensionTools);
-      const names = new Set([...this.extensionTools, ...sources.keys()]);
+      const extensionTools = this.extensionToolNames(profile);
+      const sources = await this.packageToolSources(runtimeSettings, extensionTools);
+      const names = new Set([...extensionTools, ...sources.keys()]);
       return [...BUILTIN_TOOLS.map((name) => ({ name, kind, source: "builtin" as const, enabled: this.enabled(settings, kind, name) })), ...[...names].sort().map((name) => sources.has(name) ? ({ name, kind, source: "package" as const, package: sources.get(name), enabled: this.enabled(settings, kind, name) }) : ({ name, kind, source: "extension" as const, enabled: this.enabled(settings, kind, name) }))];
     }
-    return [...(await this.names("extensions")).map(({ name, path }) => ({ name, kind, path, source: "shared" as const, enabled: protectedExtensions.has(name) ? true : this.enabled(runtimeSettings, kind, name, path), protected: protectedExtensions.has(name) || undefined })), ...(await this.packageExtensions(runtimeSettings)).map(({ name, path, package: packageName }) => ({ name, kind, path, source: "package" as const, package: packageName, enabled: true }))];
+    return [...(await this.names("extensions")).map(({ name, path }) => ({ name, kind, path, source: "shared" as const, enabled: protectedExtensions.has(name) ? true : this.enabled(runtimeSettings, kind, name, path), protected: protectedExtensions.has(name) || undefined })), ...(await this.packageExtensions(runtimeSettings)).map(({ name, path, package: packageName }) => ({ name, kind, path, source: "package" as const, package: packageName, enabled: protectedExtensions.has(name) ? true : this.enabled(runtimeSettings, kind, name, path), protected: protectedExtensions.has(name) || undefined }))];
   }
 
-  async resource(profile: string, kind: ResourceKind, name: string, source?: "shared" | "profile"): Promise<Resource> {
+  async resource(profile: string, kind: ResourceKind, name: string, source?: SkillResourceSource): Promise<Resource> {
     const resource = (await this.resources(profile, kind)).find((item) => item.name === name && (!source || item.source === source));
     if (!resource) throw Object.assign(new Error("Resource not found"), { status: 404 });
     return resource;
   }
 
   private async skillPaths(name: string, settings: ProfileSettings): Promise<string[]> {
-    return (await this.skillResources(name, settings)).filter((skill) => skill.enabled).map((skill) => skill.path!).filter(Boolean);
+    const runtimeSettings = name === "default" ? settings : await this.readSettings("default");
+    return (await this.skillResources(name, settings, runtimeSettings)).filter((skill) => skill.enabled).map((skill) => skill.path!).filter(Boolean);
   }
 
   private async materializeResources(name: string, settings: ProfileSettings): Promise<ProfileSettings> {
@@ -232,7 +269,7 @@ export class ProfileStore {
     return this.skillSources(profile, settings);
   }
 
-  async readSkillDocument(profile: string, name: string, source?: "shared" | "profile"): Promise<{ name: string; frontmatter: Record<string, string>; content: string }> {
+  async readSkillDocument(profile: string, name: string, source?: SkillResourceSource): Promise<{ name: string; frontmatter: Record<string, string>; content: string }> {
     const skill = await this.resource(profile, "skills", name, source);
     if (!skill.path) throw Object.assign(new Error("Skill document not found"), { status: 404 });
     const document = await readFile(join(skill.path, "SKILL.md"), "utf8");
@@ -247,9 +284,22 @@ export class ProfileStore {
     return { name, frontmatter, content: match ? document.slice(match[0].length) : document };
   }
 
-  async setResource(profile: string, kind: ResourceKind, name: string, enabled: boolean, source?: "shared" | "profile"): Promise<Resource> {
+  async setResource(profile: string, kind: ResourceKind, name: string, enabled: boolean, source?: SkillResourceSource): Promise<Resource> {
     const current = await this.resource(profile, kind, name, source);
     if (current.protected && !enabled) throw Object.assign(new Error("This extension is required and cannot be disabled."), { status: 422 });
+    // The default profile uses Pi's defaultTools setting for native tool state
+    // unless it already has a legacy explicit enabledTools policy. Named profiles
+    // retain their explicit enabledTools policy.
+    if (kind === "tools" && current.source === "builtin" && profile === "default") {
+      const settings = await this.readSettings(profile);
+      if (!settings.profile?.enabledTools) {
+        const tools = updatedBuiltinTools(settings, name, enabled);
+        if (tools) settings.defaultTools = tools;
+        else delete settings.defaultTools;
+        await this.writeSettings(profile, settings);
+        return this.resource(profile, kind, name, source);
+      }
+    }
     // Extensions are shared runtime resources, so toggling one always updates
     // the default runtime rather than materializing it in a profile workspace.
     const settingsProfile = kind === "extensions" ? "default" : profile;
@@ -264,8 +314,9 @@ export class ProfileStore {
     return this.resource(profile, kind, name, source);
   }
 
-  async deleteSkill(profile: string, name: string, source?: "shared" | "profile"): Promise<void> {
+  async deleteSkill(profile: string, name: string, source?: SkillResourceSource): Promise<void> {
     const current = await this.resource(profile, "skills", name, source);
+    if (current.source === "package") throw Object.assign(new Error("Package Skills cannot be deleted here."), { status: 403 });
     if (current.source === "shared" && profile !== "default") { await this.setResource(profile, "skills", name, false, "shared"); return; }
     if (!current.path) throw Object.assign(new Error("Skill path not found."), { status: 404 });
     await rm(current.path, { recursive: true, force: false });
@@ -290,10 +341,9 @@ export class ProfileStore {
     await ensureProfileSandbox(destination, resolve(process.argv[1]));
     await writeFile(join(destination, "SOUL.md"), "", "utf8");
     await writeFile(join(destination, "guardrails.json"), "{\n  \"guardrails\": []\n}\n", "utf8");
-    for (const file of ["auth.json", "models.json"]) {
-      const source = join(this.agentDir, file);
-      if (existsSync(source)) await copyFile(source, join(destination, file));
-    }
+    const auth = join(this.agentDir, "auth.json");
+    if (existsSync(auth)) await copyFile(auth, join(destination, "auth.json"));
+    await this.linkSharedModels(name);
     return { name, path: destination };
   }