@oyasmi/pipiclaw 0.6.2 → 0.6.4

package/dist/tools/skill-manage.d.ts

@@ -0,0 +1,34 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+declare const skillManageSchema: import("@sinclair/typebox").TObject<{
+    label: import("@sinclair/typebox").TString;
+    action: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    content: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    filePath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    find: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    replace: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type SkillManageAction = "create" | "patch" | "write_file";
+export interface SkillManageResult {
+    action: SkillManageAction;
+    name: string;
+    path: string;
+    bytesWritten: number;
+    requiresResourceRefresh: boolean;
+    notice: string;
+}
+export interface SkillManageRequest {
+    action: SkillManageAction;
+    name: string;
+    content?: string;
+    filePath?: string;
+    find?: string;
+    replace?: string;
+}
+export interface SkillManageToolOptions {
+    workspaceDir: string;
+    workspacePath: string;
+}
+export declare function manageWorkspaceSkill(options: SkillManageToolOptions, request: SkillManageRequest): Promise<SkillManageResult>;
+export declare function createSkillManageTool(options: SkillManageToolOptions): AgentTool<typeof skillManageSchema>;
+export {};

package/dist/tools/skill-manage.js

@@ -0,0 +1,138 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { createAtomicTempPath, writeFileAtomically } from "../shared/atomic-file.js";
+import { resolveSkillPath, resolveSkillSupportingFile, scanSkillContent, validateSkillMarkdown, } from "./skill-security.js";
+const skillManageSchema = Type.Object({
+    label: Type.String({ description: "Brief description of the skill management change (shown to user)" }),
+    action: Type.String({ description: 'Supported actions: "create", "patch", or "write_file".' }),
+    name: Type.String({ description: "Workspace skill name" }),
+    content: Type.Optional(Type.String({ description: "Full content for create/write_file." })),
+    filePath: Type.Optional(Type.String({
+        description: "Optional supporting file path for patch/write_file. Defaults to SKILL.md for patch. Supporting files must be under references/, templates/, scripts/, or assets/.",
+    })),
+    find: Type.Optional(Type.String({ description: "Exact text to replace when action is patch." })),
+    replace: Type.Optional(Type.String({ description: "Replacement text when action is patch." })),
+});
+function toWorkspacePath(options, hostPath) {
+    if (hostPath.startsWith(options.workspaceDir)) {
+        return `${options.workspacePath}${hostPath.slice(options.workspaceDir.length)}`;
+    }
+    return hostPath;
+}
+function parseAction(action) {
+    if (action === "create" || action === "patch" || action === "write_file") {
+        return action;
+    }
+    throw new Error('Unsupported skill action. Use "create", "patch", or "write_file".');
+}
+function ensureSkillMarkdownSafe(content, name) {
+    const validation = validateSkillMarkdown(content, name);
+    if (!validation.ok) {
+        throw new Error(validation.error);
+    }
+}
+function ensureSupportingFileSafe(content) {
+    const validation = scanSkillContent(content);
+    if (!validation.ok) {
+        throw new Error(validation.error);
+    }
+}
+function applyUniquePatch(content, find, replace) {
+    if (!find) {
+        throw new Error("Patch requires a non-empty find string.");
+    }
+    const first = content.indexOf(find);
+    if (first < 0) {
+        throw new Error("Patch find string was not found.");
+    }
+    if (content.indexOf(find, first + find.length) >= 0) {
+        throw new Error("Patch find string matched multiple locations.");
+    }
+    return `${content.slice(0, first)}${replace}${content.slice(first + find.length)}`;
+}
+export async function manageWorkspaceSkill(options, request) {
+    const skillDir = resolveSkillPath(options.workspaceDir, request.name);
+    const skillPath = join(skillDir, "SKILL.md");
+    if (request.action === "create") {
+        if (existsSync(skillPath)) {
+            throw new Error(`Workspace skill "${request.name}" already exists.`);
+        }
+        const content = request.content ?? "";
+        ensureSkillMarkdownSafe(content, request.name);
+        await writeFileAtomically(skillPath, content);
+        return {
+            action: "create",
+            name: request.name,
+            path: toWorkspacePath(options, skillPath),
+            bytesWritten: Buffer.byteLength(content, "utf-8"),
+            requiresResourceRefresh: true,
+            notice: `已沉淀：创建 workspace skill \`${request.name}\`。`,
+        };
+    }
+    if (!existsSync(skillPath)) {
+        throw new Error(`Workspace skill "${request.name}" does not exist.`);
+    }
+    if (request.action === "write_file") {
+        if (!request.filePath) {
+            throw new Error("write_file requires filePath.");
+        }
+        const content = request.content ?? "";
+        const targetPath = resolveSkillSupportingFile(skillDir, request.filePath);
+        ensureSupportingFileSafe(content);
+        await writeFileAtomically(targetPath, content);
+        return {
+            action: "write_file",
+            name: request.name,
+            path: toWorkspacePath(options, targetPath),
+            bytesWritten: Buffer.byteLength(content, "utf-8"),
+            requiresResourceRefresh: true,
+            notice: `已沉淀：更新 workspace skill \`${request.name}\` 的支持文件。`,
+        };
+    }
+    const targetPath = request.filePath ? resolveSkillSupportingFile(skillDir, request.filePath) : skillPath;
+    const original = await readFile(targetPath, "utf-8");
+    const nextContent = applyUniquePatch(original, request.find ?? "", request.replace ?? "");
+    if (targetPath === skillPath) {
+        ensureSkillMarkdownSafe(nextContent, request.name);
+    }
+    else {
+        ensureSupportingFileSafe(nextContent);
+    }
+    const tempPath = createAtomicTempPath(targetPath);
+    await writeFileAtomically(targetPath, nextContent, tempPath);
+    return {
+        action: "patch",
+        name: request.name,
+        path: toWorkspacePath(options, targetPath),
+        bytesWritten: Buffer.byteLength(nextContent, "utf-8"),
+        requiresResourceRefresh: true,
+        notice: `已沉淀：更新 workspace skill \`${request.name}\`。`,
+    };
+}
+export function createSkillManageTool(options) {
+    return {
+        name: "skill_manage",
+        label: "skill_manage",
+        description: "Create or update workspace-level Pipiclaw skills as procedural memory. Supports create, patch, and write_file only; no channel-scoped skills.",
+        parameters: skillManageSchema,
+        execute: async (_toolCallId, args) => {
+            const result = await manageWorkspaceSkill(options, {
+                action: parseAction(args.action),
+                name: args.name,
+                content: args.content,
+                filePath: args.filePath,
+                find: args.find,
+                replace: args.replace,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                details: {
+                    kind: "skill_manage",
+                    ...result,
+                },
+            };
+        },
+    };
+}

package/dist/tools/skill-security.d.ts

@@ -0,0 +1,10 @@
+export interface SkillValidationResult {
+    ok: boolean;
+    error?: string;
+}
+export declare function validateSkillName(name: string): SkillValidationResult;
+export declare function validateSkillFrontmatter(content: string, expectedName: string): SkillValidationResult;
+export declare function resolveSkillPath(workspaceDir: string, name: string): string;
+export declare function resolveSkillSupportingFile(skillDir: string, filePath: string): string;
+export declare function scanSkillContent(content: string): SkillValidationResult;
+export declare function validateSkillMarkdown(content: string, expectedName: string): SkillValidationResult;

package/dist/tools/skill-security.js

@@ -0,0 +1,111 @@
+import { resolve } from "node:path";
+const SKILL_NAME_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+const ALLOWED_SUPPORTING_DIRS = new Set(["references", "templates", "scripts", "assets"]);
+const BLOCKED_CONTENT_PATTERNS = [
+    { pattern: /ignore\s+(all\s+)?(previous|prior)\s+instructions/i, message: "contains prompt-injection wording" },
+    {
+        pattern: /disregard\s+(all\s+)?(previous|prior|above)\s+(instructions|rules)/i,
+        message: "contains prompt-injection wording",
+    },
+    { pattern: /you\s+are\s+now\s+(a|an|the)\s+/i, message: "contains prompt-injection wording" },
+    { pattern: /new\s+system\s+prompt/i, message: "contains prompt-injection wording" },
+    { pattern: /exfiltrat(e|ion)|steal\s+(secrets?|credentials?|tokens?)/i, message: "contains exfiltration wording" },
+    { pattern: /rm\s+-rf\s+\/(?:\s|$)/i, message: "contains destructive root removal command" },
+    { pattern: /curl\b[\s\S]{0,120}\|\s*(?:sh|bash)\b/i, message: "contains pipe-to-shell install command" },
+    { pattern: /wget\b[\s\S]{0,120}\|\s*(?:sh|bash)\b/i, message: "contains pipe-to-shell install command" },
+    {
+        pattern: /cat\s+.*(?:\.env|id_rsa|id_ed25519|credentials|\.ssh\/|\.aws\/)/i,
+        message: "contains credential file access",
+    },
+    { pattern: /chmod\s+(?:777|[+]s)\b/i, message: "contains dangerous permission change" },
+    { pattern: /dd\s+if=.*of=\/dev\//i, message: "contains raw device write command" },
+    { pattern: /\b(?:mkfs|fdisk)\b/i, message: "contains disk formatting command" },
+    { pattern: /[\u200B-\u200D\uFEFF]/u, message: "contains invisible unicode characters" },
+];
+function ok() {
+    return { ok: true };
+}
+function fail(error) {
+    return { ok: false, error };
+}
+function parseFrontmatter(content) {
+    const match = content.replace(/\r\n/g, "\n").match(FRONTMATTER_REGEX);
+    if (!match) {
+        return null;
+    }
+    const data = {};
+    for (const line of (match[1] ?? "").split("\n")) {
+        const fieldMatch = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!fieldMatch) {
+            continue;
+        }
+        data[fieldMatch[1]] = fieldMatch[2].replace(/^["']|["']$/g, "").trim();
+    }
+    return { data, body: match[2] ?? "" };
+}
+export function validateSkillName(name) {
+    if (!SKILL_NAME_REGEX.test(name)) {
+        return fail("Skill name must match [a-z0-9]+(-[a-z0-9]+)*.");
+    }
+    return ok();
+}
+export function validateSkillFrontmatter(content, expectedName) {
+    const parsed = parseFrontmatter(content);
+    if (!parsed) {
+        return fail("SKILL.md must start with YAML frontmatter.");
+    }
+    if (parsed.data.name !== expectedName) {
+        return fail(`Skill frontmatter name must be "${expectedName}".`);
+    }
+    if (!parsed.data.description) {
+        return fail("Skill frontmatter must include a non-empty description.");
+    }
+    if (!parsed.body.trim()) {
+        return fail("Skill body must be non-empty.");
+    }
+    return ok();
+}
+export function resolveSkillPath(workspaceDir, name) {
+    const result = validateSkillName(name);
+    if (!result.ok) {
+        throw new Error(result.error);
+    }
+    const skillsDir = resolve(workspaceDir, "skills");
+    const skillDir = resolve(skillsDir, name);
+    if (skillDir !== resolve(skillsDir, name) || !skillDir.startsWith(`${skillsDir}/`)) {
+        throw new Error("Resolved skill path escaped workspace skills directory.");
+    }
+    return skillDir;
+}
+export function resolveSkillSupportingFile(skillDir, filePath) {
+    const normalized = filePath.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!normalized || normalized.includes("..")) {
+        throw new Error("Supporting file path must not be empty or contain '..'.");
+    }
+    const [topLevel] = normalized.split("/");
+    if (!topLevel || !ALLOWED_SUPPORTING_DIRS.has(topLevel)) {
+        throw new Error("Supporting files must live under references/, templates/, scripts/, or assets/.");
+    }
+    const base = resolve(skillDir);
+    const resolved = resolve(base, normalized);
+    if (!resolved.startsWith(`${base}/`)) {
+        throw new Error("Supporting file path escaped the skill directory.");
+    }
+    return resolved;
+}
+export function scanSkillContent(content) {
+    for (const { pattern, message } of BLOCKED_CONTENT_PATTERNS) {
+        if (pattern.test(content)) {
+            return fail(message);
+        }
+    }
+    return ok();
+}
+export function validateSkillMarkdown(content, expectedName) {
+    const frontmatter = validateSkillFrontmatter(content, expectedName);
+    if (!frontmatter.ok) {
+        return frontmatter;
+    }
+    return scanSkillContent(content);
+}

package/dist/tools/skill-view.d.ts

@@ -0,0 +1,12 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+declare const skillViewSchema: import("@sinclair/typebox").TObject<{
+    label: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    filePath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export interface SkillViewToolOptions {
+    workspaceDir: string;
+    workspacePath: string;
+}
+export declare function createSkillViewTool(options: SkillViewToolOptions): AgentTool<typeof skillViewSchema>;
+export {};

package/dist/tools/skill-view.js

@@ -0,0 +1,43 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { resolveSkillPath, resolveSkillSupportingFile } from "./skill-security.js";
+const skillViewSchema = Type.Object({
+    label: Type.String({ description: "Brief description of why you're viewing this skill (shown to user)" }),
+    name: Type.String({ description: "Workspace skill name" }),
+    filePath: Type.Optional(Type.String({
+        description: "Optional file path inside the skill directory. Defaults to SKILL.md. Supporting files must be under references/, templates/, scripts/, or assets/.",
+    })),
+});
+function toWorkspacePath(options, hostPath) {
+    if (hostPath.startsWith(options.workspaceDir)) {
+        return `${options.workspacePath}${hostPath.slice(options.workspaceDir.length)}`;
+    }
+    return hostPath;
+}
+export function createSkillViewTool(options) {
+    return {
+        name: "skill_view",
+        label: "skill_view",
+        description: "View a workspace-level skill SKILL.md file or an allowed supporting file.",
+        parameters: skillViewSchema,
+        execute: async (_toolCallId, { name, filePath }) => {
+            const skillDir = resolveSkillPath(options.workspaceDir, name);
+            const targetPath = filePath ? resolveSkillSupportingFile(skillDir, filePath) : join(skillDir, "SKILL.md");
+            const content = await readFile(targetPath, "utf-8");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            name,
+                            path: toWorkspacePath(options, targetPath),
+                            content,
+                        }, null, 2),
+                    },
+                ],
+                details: { kind: "skill_view", name, path: toWorkspacePath(options, targetPath) },
+            };
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oyasmi/pipiclaw",
-	"version": "0.6.2",
+	"version": "0.6.4",
 	"description": "An AI assistant runtime for coding and team workflows, with DingTalk AI Cards, sub-agents, memory, and scheduled events.",
 	"type": "module",
 	"bin": {
@@ -21,8 +21,8 @@
 		"LICENSE"
 	],
 	"scripts": {
-		"clean": "shx rm -rf dist coverage",
-		"build": "tsc -p tsconfig.build.json && shx chmod +x dist/main.js",
+		"clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true }); require('node:fs').rmSync('coverage', { recursive: true, force: true });\"",
+		"build": "tsc -p tsconfig.build.json && node -e \"require('node:fs').chmodSync('dist/main.js', 0o755)\"",
 		"dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
 		"lint": "biome check .",
 		"typecheck": "tsc --noEmit -p tsconfig.json",
@@ -39,7 +39,6 @@
 		"@mozilla/readability": "^0.6.0",
 		"@sinclair/typebox": "^0.34.0",
 		"axios": "^1.7.0",
-		"chalk": "^5.6.2",
 		"croner": "^9.1.0",
 		"diff": "^8.0.2",
 		"dingtalk-stream": "^2.1.4",
@@ -51,11 +50,9 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.3.5",
-		"@types/diff": "^7.0.2",
 		"@types/jsdom": "^28.0.1",
 		"@types/node": "^24.3.0",
 		"@vitest/coverage-v8": "^3.2.4",
-		"shx": "^0.4.0",
 		"typescript": "^5.7.3",
 		"vitest": "^3.2.4"
 	},