pi-feats 0.1.4 → 0.1.7

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

@@ -1,20 +1,34 @@
 import { existsSync } from "node:fs";
-import { copyFile, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { copyFile, cp, 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";
+import { packageExtensions } from "../lib/package-resources.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 SkillResourceSource = "shared" | "profile" | "package";
-type ProfilePolicy = Partial<Record<PolicyKey, string[]>> & { skillSources?: SkillSources; contextMemory?: { mode: "file"; target: "profile" | "identity" } | { mode: "handler"; handler: string } };
+export type ProfileMetadata = { description: string; tags: string[] };
+type ProfilePolicy = Partial<Record<PolicyKey, string[]>> & Partial<ProfileMetadata> & { 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 };
 
 const validName = (name: string) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(name);
+const maxProfileDescriptionLength = 500;
+const maxProfileTags = 20;
+const maxProfileTagLength = 50;
+const profileMetadata = (value: unknown): ProfileMetadata => {
+  const input = value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+  if (input.description !== undefined && (typeof input.description !== "string" || input.description.length > maxProfileDescriptionLength)) throw Object.assign(new Error(`description must be a string of at most ${maxProfileDescriptionLength} characters.`), { status: 400 });
+  if (input.tags !== undefined && (!Array.isArray(input.tags) || input.tags.some((tag) => typeof tag !== "string"))) throw Object.assign(new Error("tags must be an array of strings."), { status: 400 });
+  const tags = [...new Map((input.tags as string[] | undefined ?? []).map((tag) => tag.trim()).filter(Boolean).map((tag) => [tag.toLocaleLowerCase(), tag])).values()];
+  if (tags.length > maxProfileTags || tags.some((tag) => tag.length > maxProfileTagLength)) throw Object.assign(new Error(`Use at most ${maxProfileTags} tags of at most ${maxProfileTagLength} characters.`), { status: 400 });
+  return { description: (input.description as string | undefined ?? "").trim(), tags };
+};
 const policyKey: Record<ResourceKind, PolicyKey> = {
   tools: "enabledTools",
   skills: "enabledSkills",
@@ -24,12 +38,13 @@ const protectedExtensions = new Set(["profiles", "api-server"]);
 
 export class ProfileStore {
   private readonly extensionTools = new Map<string, Set<string>>();
+  readonly agentDir: string;
 
-  constructor(readonly agentDir: string) {}
+  constructor(agentDir: string) { this.agentDir = agentDir; }
 
   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.includes(name)) tools.add(name);
+    for (const name of names) if (name && !(BUILTIN_TOOLS as readonly string[]).includes(name)) tools.add(name);
     this.extensionTools.set(profile, tools);
   }
 
@@ -49,6 +64,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 };
@@ -62,6 +84,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 {};
@@ -70,14 +93,13 @@ export class ProfileStore {
     }
   }
 
-  async list(): Promise<Array<{ name: string; path: string }>> {
-    const profiles = [{ name: "default", path: this.agentDir }];
-    if (!existsSync(this.profilesDir())) return profiles;
-    for (const entry of await readdir(this.profilesDir(), { withFileTypes: true })) {
-      if (entry.isDirectory() && existsSync(join(this.profilesDir(), entry.name, "settings.json"))) {
-        profiles.push({ name: entry.name, path: this.directory(entry.name) });
-      }
-    }
+  async list(): Promise<Array<{ name: string; path: string } & ProfileMetadata>> {
+    const names = ["default"];
+    if (existsSync(this.profilesDir())) for (const entry of await readdir(this.profilesDir(), { withFileTypes: true })) if (entry.isDirectory() && existsSync(join(this.profilesDir(), entry.name, "settings.json"))) names.push(entry.name);
+    const profiles = await Promise.all(names.map(async (name) => {
+      const settings = await this.readSettings(name);
+      return { name, path: this.directory(name), ...profileMetadata(settings.profile) };
+    }));
     return profiles.sort((a, b) => a.name.localeCompare(b.name));
   }
 
@@ -106,6 +128,7 @@ 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}`);
@@ -172,19 +195,15 @@ export class ProfileStore {
   }
 
   private async packageExtensions(settings: ProfileSettings): Promise<Array<{ name: string; path: string; package: string }>> {
-    const entries: Array<{ name: string; path: string; package: string }> = [];
-    for (const pkg of await this.configuredPackages(settings)) {
-      for (const extension of Array.isArray(pkg.manifest?.pi?.extensions) ? pkg.manifest.pi.extensions : []) if (typeof extension === "string") entries.push({ name: extension.split("/").pop()?.replace(/\.(?:ts|js)$/, "") ?? pkg.name, path: join(pkg.base, extension), package: pkg.name });
-    }
-    return entries;
+    return packageExtensions(await this.configuredPackages(settings)).map(({ name, path, packageName }) => ({ name, path, package: packageName }));
   }
 
   private async packageToolSources(settings: ProfileSettings, names: Iterable<string>): Promise<Map<string, string>> {
     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;
   }
@@ -276,6 +295,19 @@ export class ProfileStore {
   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;
@@ -299,29 +331,67 @@ export class ProfileStore {
     await this.refreshSkills(profile);
   }
 
-  async create(name: string): Promise<{ name: string; path: string }> {
+  async create(name: string, metadata: unknown = {}, cloneFrom?: string): Promise<{ name: string; path: string } & ProfileMetadata> {
     if (!validName(name) || name === "default") throw Object.assign(new Error("Invalid profile name"), { status: 400 });
     const destination = this.directory(name);
     if (existsSync(destination)) throw Object.assign(new Error("Profile already exists"), { status: 409 });
-    await mkdir(join(destination, "sessions"), { recursive: true });
-    let base: ProfileSettings = {};
-    try { base = await this.readSettings("default"); } catch {}
-    const { packages: _packages, extensions: _extensions, ...profileBase } = base;
-    const settings: ProfileSettings = {
-      ...profileBase,
-      defaultTools: BUILTIN_TOOLS,
-      sandbox: true,
-      profile: { enabledTools: ["*"], enabledSkills: ["*"], enabledProfileSkills: ["*"], skillSources: { shared: true, profile: false } },
-    };
-    await this.writeSettings(name, settings);
-    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 details = profileMetadata(metadata);
+    if (cloneFrom !== undefined && (typeof cloneFrom !== "string" || !validName(cloneFrom) || cloneFrom === "default")) throw Object.assign(new Error("Clone source must be an existing named profile."), { status: 400 });
+
+    let sourceSettings: ProfileSettings | undefined;
+    let sourceDirectory: string | undefined;
+    if (cloneFrom) {
+      sourceSettings = await this.readSettings(cloneFrom);
+      sourceDirectory = this.directory(cloneFrom);
     }
-    return { name, path: destination };
+
+    try {
+      await mkdir(join(destination, "sessions"), { recursive: true });
+      let settings: ProfileSettings;
+      if (sourceSettings && sourceDirectory) {
+        const sourceSkills = join(sourceDirectory, "skills");
+        if (existsSync(sourceSkills)) await cp(sourceSkills, join(destination, "skills"), { recursive: true, force: false });
+        for (const file of ["SOUL.md", "REFINE.md", "guardrails.json", ".env", "auth.json"]) {
+          const source = join(sourceDirectory, file);
+          if (existsSync(source)) await copyFile(source, join(destination, file));
+        }
+        settings = {
+          ...sourceSettings,
+          sandbox: true,
+          profile: { ...(sourceSettings.profile ?? {}), ...details },
+        };
+      } else {
+        let base: ProfileSettings = {};
+        try { base = await this.readSettings("default"); } catch {}
+        const { packages: _packages, extensions: _extensions, ...profileBase } = base;
+        settings = {
+          ...profileBase,
+          defaultTools: BUILTIN_TOOLS,
+          sandbox: true,
+          profile: { enabledTools: ["*"], enabledSkills: ["*"], enabledProfileSkills: ["*"], skillSources: { shared: true, profile: false }, ...details },
+        };
+      }
+      await this.writeSettings(name, settings);
+      await ensureProfileSandbox(destination, resolve(process.argv[1]));
+      if (!sourceSettings) {
+        await writeFile(join(destination, "SOUL.md"), "", "utf8");
+        await writeFile(join(destination, "guardrails.json"), "{\n  \"guardrails\": []\n}\n", "utf8");
+        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, ...details };
+    } catch (error) {
+      await rm(destination, { recursive: true, force: true });
+      throw error;
+    }
+  }
+
+  async updateMetadata(name: string, metadata: unknown): Promise<{ name: string; path: string } & ProfileMetadata> {
+    const details = profileMetadata(metadata);
+    const settings = await this.readSettings(name);
+    await this.writeSettings(name, { ...settings, profile: { ...(settings.profile ?? {}), ...details } });
+    return { name, path: this.directory(name), ...details };
   }
 
   async delete(name: string): Promise<void> {