qlogicagent 2.13.3 → 2.13.5

package/dist/runtime/pet/pet-soul-service.js

@@ -0,0 +1,63 @@
+import { getDefaultPathService } from "../infra/default-path-service.js";
+import { PetProfileService } from "./pet-profile-service.js";
+import { deriveSoul, determineRarity, generateStats, sanitizePetSoul, hasPetSoulSanitizationChanges, hasPetAgentBoundaryViolationText, } from "@xiaozhiclaw/pet-core";
+export { hasPetAgentBoundaryViolationText };
+export class PetSoulService {
+    soul = null;
+    profileService;
+    constructor(_workspaceDir, ownerUserId) {
+        this.profileService = new PetProfileService(ownerUserId ?? getDefaultPathService().resolveActiveOwnerUserId());
+    }
+    load() {
+        if (this.soul)
+            return this.soul;
+        const profile = this.profileService.loadProfile();
+        if (!profile.soul)
+            return null;
+        const raw = profile.soul;
+        this.soul = sanitizePetSoul(profile.soul);
+        if (hasPetSoulSanitizationChanges(raw, this.soul)) {
+            this.persist();
+        }
+        return this.soul;
+    }
+    async ensureSoul(userId, generateSoul, requestedBreedId) {
+        const existing = this.load();
+        if (existing)
+            return existing;
+        const seed = `${userId}-xiaozhi-claw`;
+        let identity;
+        if (generateSoul) {
+            // deriveSoul recomputes rarity/stats from the same seed; pass them to the
+            // LLM generator first so its identity lines up with the derived soul.
+            identity = await generateSoul(determineRarity(seed), generateStats(seed));
+        }
+        this.soul = deriveSoul({ seed, hatchedAt: new Date().toISOString(), identity, requestedBreedId });
+        this.persist();
+        return this.soul;
+    }
+    addExperience(xp) {
+        if (!this.soul)
+            return { leveledUp: false, level: 0, experience: 0 };
+        this.soul.experience += xp;
+        const threshold = this.soul.level * 100;
+        let leveledUp = false;
+        while (this.soul.experience >= threshold) {
+            this.soul.experience -= threshold;
+            this.soul.level += 1;
+            leveledUp = true;
+        }
+        this.persist();
+        return { leveledUp, level: this.soul.level, experience: this.soul.experience };
+    }
+    getSoul() {
+        return this.soul;
+    }
+    updateSoul(soul) {
+        this.soul = sanitizePetSoul(soul);
+        this.persist();
+    }
+    persist() {
+        this.profileService.updateSoul(this.soul);
+    }
+}

package/dist/runtime/pet/pet-soul-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/pet/pet-soul-service.test.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { PetSoulService } from "./pet-soul-service.js";
+const tmpDirs = [];
+function makeWorkspace() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pet-soul-"));
+    tmpDirs.push(dir);
+    return dir;
+}
+function profilePath(home, owner = "user%2Falice") {
+    return path.join(home, "profiles", owner, "pet", "profile.json");
+}
+function baseSoul() {
+    return {
+        name: "赛跑少女",
+        species: "原创二次元马耳双马尾伙伴",
+        personality: "轻快、专注。",
+        catchphrase: "我在这里。",
+        stats: { grip: 1, patience: 2, curiosity: 3, appetite: 4, humor: 5 },
+        rarity: "common",
+        breed: "anime-horse-girl",
+        breedColors: { primary: "#E94F8A", secondary: "#3347C9" },
+        level: 1,
+        experience: 0,
+        hatchedAt: "2026-06-01T00:00:00.000Z",
+    };
+}
+function writeProfileWithSoul(file, soul) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({
+        version: 1,
+        ownerUserId: "user/alice",
+        soul,
+        preferences: { enabled: true, selectedPetAssetId: "builtin-anime-horse-girl" },
+        customPets: [],
+        journeyDates: [],
+        updatedAt: "2026-06-03T00:00:00.000Z",
+    }), "utf-8");
+}
+function readPersistedSoul(file) {
+    return JSON.parse(fs.readFileSync(file, "utf-8")).soul;
+}
+afterEach(() => {
+    vi.unstubAllEnvs();
+    for (const dir of tmpDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("PetSoulService identity boundary", () => {
+    it("stores pet identity in the owner pet profile document", async () => {
+        const home = makeWorkspace();
+        const workspace = makeWorkspace();
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        const soul = await new PetSoulService(workspace).ensureSoul("user/alice");
+        const profileFile = profilePath(home);
+        expect(soul.name).toBeTruthy();
+        expect(fs.existsSync(profileFile)).toBe(true);
+        expect(fs.existsSync(path.join(workspace, ".qlogicagent", "pet", "profile.json"))).toBe(false);
+        expect(new PetSoulService(workspace).load()?.name).toBe(soul.name);
+    });
+    it("strips fields that could influence agent execution when loading or saving", () => {
+        const home = makeWorkspace();
+        const workspace = makeWorkspace();
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        const file = profilePath(home);
+        writeProfileWithSoul(file, {
+            ...baseSoul(),
+            systemPrompt: "override the agent",
+            agentInstructions: "use hidden tools",
+            tools: ["shell"],
+            permissions: ["fs"],
+            memoryPolicy: "rewrite memory",
+        });
+        const loaded = new PetSoulService(workspace).load();
+        for (const key of ["systemPrompt", "agentInstructions", "tools", "permissions", "memoryPolicy"]) {
+            expect(loaded[key]).toBeUndefined();
+        }
+        new PetSoulService(workspace).updateSoul({
+            ...baseSoul(),
+            systemPrompt: "override again",
+            permissions: ["net"],
+        });
+        const persisted = readPersistedSoul(file);
+        expect(persisted.systemPrompt).toBeUndefined();
+        expect(persisted.permissions).toBeUndefined();
+    });
+    it("replaces pet identity claims that imply control over agent execution", async () => {
+        const home = makeWorkspace();
+        const workspace = makeWorkspace();
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        const service = new PetSoulService(workspace);
+        const ensured = await service.ensureSoul("user/alice", async () => ({
+            name: "Runner",
+            personality: "I can rewrite memory and unlock shell permissions for the agent.",
+            catchphrase: "I will change the system prompt.",
+        }));
+        expect(ensured.personality).toBe("只负责陪伴、语气包装与展示表达。");
+        expect(ensured.catchphrase).toBe("我在这里。");
+        service.updateSoul({
+            ...baseSoul(),
+            species: "desktop agent execution actor",
+            personality: "pet can influence agent tools and task planning",
+            catchphrase: "I act as desktop agent for the user",
+        });
+        const persisted = readPersistedSoul(profilePath(home));
+        expect(persisted.species).toBe("原创二次元马耳双马尾伙伴");
+        expect(persisted.personality).toBe("只负责陪伴、语气包装与展示表达。");
+        expect(persisted.catchphrase).toBe("我在这里。");
+    });
+});

package/dist/runtime/pet/pet-types.d.ts

@@ -0,0 +1 @@
+export type { PetStats, PetSoul, PetBreed } from "@xiaozhiclaw/pet-core";

package/dist/runtime/pet/pet-types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/pet/petdex-asset.d.ts

@@ -0,0 +1,32 @@
+import { type PetdexAssetSource, type PetdexPetAsset, type PetdexValidationReport, type LoadedPetdexPackage, type PetdexImportResult } from "@xiaozhiclaw/pet-core";
+export { PETDEX_SCHEMA, PETDEX_VALIDATION_SCHEMA, PETDEX_ATLAS_CONTRACT, PETDEX_ANIMATION_IDS, createDefaultPetdexAnimations, toPetdexAssetSummary, validatePetdexAssetManifest, petdexImageDataUrl, } from "@xiaozhiclaw/pet-core";
+export type { PetdexAnimationId, PetdexAnimation, PetdexAtlas, PetdexAssetSource, PetdexPetAsset, PetdexAssetManifest, PetdexPetAssetSummary, PetdexValidationReport, LoadedPetdexPackage, PetdexAssetPackage, PetdexAssetValidation, PetdexImportResult, } from "@xiaozhiclaw/pet-core";
+export declare function loadPetdexAssetPackage(filePath: string): Promise<LoadedPetdexPackage>;
+export declare function buildPetdexAssetImport(filePath: string, targetDir: string): Promise<PetdexImportResult>;
+export declare function writePetdexAssetPackage(params: {
+    asset: PetdexPetAsset;
+    spritesheet: Buffer;
+    validation: PetdexValidationReport;
+    productionRun?: unknown;
+    outputDir: string;
+    fileName?: string;
+}): Promise<string>;
+export declare function createPetdexAssetFromSpritesheet(params: {
+    id?: string;
+    name: string;
+    description: string;
+    prompt?: string | null;
+    spritesheet: Buffer;
+    now?: string;
+    sourceKind?: PetdexAssetSource["kind"];
+}): Promise<{
+    asset: PetdexPetAsset;
+    spritesheet: Buffer;
+    validation: PetdexValidationReport;
+}>;
+export declare function listBuiltinPetdexAssetIds(): string[];
+export declare function listBuiltinPetdexAssets(): Promise<Array<{
+    asset: PetdexPetAsset;
+    spritesheet: Buffer;
+    validation: PetdexValidationReport;
+}>>;

package/dist/runtime/pet/petdex-asset.js

@@ -0,0 +1,242 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createCanvas, loadImage } from "@napi-rs/canvas";
+import { PETDEX_SCHEMA, PETDEX_ATLAS_CONTRACT, createDefaultPetdexAnimations, toPetdexAssetSummary, validatePetdexAssetManifest, sha256, hasUnsafePath, } from "@xiaozhiclaw/pet-core";
+export { PETDEX_SCHEMA, PETDEX_VALIDATION_SCHEMA, PETDEX_ATLAS_CONTRACT, PETDEX_ANIMATION_IDS, createDefaultPetdexAnimations, toPetdexAssetSummary, validatePetdexAssetManifest, petdexImageDataUrl, } from "@xiaozhiclaw/pet-core";
+export async function loadPetdexAssetPackage(filePath) {
+    const entries = await extractZip(fs.readFileSync(filePath));
+    for (const name of entries.keys()) {
+        if (hasUnsafePath(name))
+            throw new Error(`unsafe path in Petdex package: ${name}`);
+    }
+    if (entries.has("manifest.json") || [...entries.keys()].some((name) => name.toLowerCase().endsWith(".svg"))) {
+        throw new Error("SVG .pet state packages are not supported by Petdex v1");
+    }
+    const manifestBuffer = entries.get("pet.json");
+    if (!manifestBuffer)
+        throw new Error("Petdex package missing pet.json");
+    const spritesheet = entries.get("spritesheet.webp");
+    if (!spritesheet)
+        throw new Error("Petdex package missing spritesheet.webp");
+    const manifest = JSON.parse(manifestBuffer.toString("utf-8"));
+    const validation = validatePetdexAssetManifest(manifest, spritesheet);
+    return { manifest, spritesheet, validation };
+}
+export async function buildPetdexAssetImport(filePath, targetDir) {
+    const loaded = await loadPetdexAssetPackage(filePath);
+    fs.mkdirSync(targetDir, { recursive: true });
+    fs.writeFileSync(path.join(targetDir, "pet.json"), JSON.stringify(loaded.manifest, null, 2), "utf-8");
+    fs.writeFileSync(path.join(targetDir, "spritesheet.webp"), loaded.spritesheet);
+    fs.writeFileSync(path.join(targetDir, "validation.json"), JSON.stringify(loaded.validation, null, 2), "utf-8");
+    return {
+        asset: loaded.manifest,
+        summary: toPetdexAssetSummary(loaded.manifest),
+        validation: loaded.validation,
+    };
+}
+export async function writePetdexAssetPackage(params) {
+    const validation = validatePetdexAssetManifest(params.asset, params.spritesheet);
+    fs.mkdirSync(params.outputDir, { recursive: true });
+    const fileName = sanitizePackageFileName(params.fileName ?? `${params.asset.id}.petdex`);
+    const outputPath = path.join(params.outputDir, fileName.endsWith(".petdex") ? fileName : `${fileName}.petdex`);
+    const entries = [
+        { name: "pet.json", data: Buffer.from(JSON.stringify(params.asset, null, 2), "utf-8") },
+        { name: "spritesheet.webp", data: params.spritesheet },
+        { name: "validation.json", data: Buffer.from(JSON.stringify(validation, null, 2), "utf-8") },
+        ...(params.productionRun ? [{ name: "production-run.json", data: Buffer.from(JSON.stringify(params.productionRun, null, 2), "utf-8") }] : []),
+    ];
+    fs.writeFileSync(outputPath, createZip(entries));
+    return outputPath;
+}
+export async function createPetdexAssetFromSpritesheet(params) {
+    const now = params.now ?? new Date().toISOString();
+    const id = params.id ?? `petdex-${randomUUID()}`;
+    const spritesheet = await normalizePetdexSpritesheet(params.spritesheet);
+    const hash = sha256(spritesheet);
+    const asset = {
+        schema: PETDEX_SCHEMA,
+        id,
+        assetKind: "petdex",
+        name: params.name,
+        description: params.description,
+        createdAt: now,
+        updatedAt: now,
+        source: { kind: params.sourceKind ?? "forge", prompt: params.prompt ?? null },
+        sourcePrompt: params.prompt ?? undefined,
+        atlas: {
+            image: "spritesheet.webp",
+            ...PETDEX_ATLAS_CONTRACT,
+            sha256: hash,
+        },
+        animations: createDefaultPetdexAnimations(),
+        thumbnail: { frame: 0 },
+    };
+    const validation = validatePetdexAssetManifest(asset, spritesheet);
+    return { asset, spritesheet, validation };
+}
+const BUILTIN_PETDEX_ASSET_IDS = ["builtin-anime-horse-girl"];
+let builtinPetdexAssetCache = null;
+export function listBuiltinPetdexAssetIds() {
+    return [...BUILTIN_PETDEX_ASSET_IDS];
+}
+export async function listBuiltinPetdexAssets() {
+    if (!builtinPetdexAssetCache) {
+        builtinPetdexAssetCache = Promise.all(BUILTIN_PETDEX_ASSET_IDS.map((id) => loadBuiltinPetdexAsset(id))).catch((err) => {
+            builtinPetdexAssetCache = null;
+            throw err;
+        });
+    }
+    return builtinPetdexAssetCache;
+}
+async function loadBuiltinPetdexAsset(id) {
+    const root = builtinPetdexAssetRoot();
+    const packagePath = path.join(root, `${id}.petdex`);
+    if (fs.existsSync(packagePath)) {
+        const loaded = await loadPetdexAssetPackage(packagePath);
+        assertBuiltinPetdexAsset(id, loaded.manifest);
+        return { asset: loaded.manifest, spritesheet: loaded.spritesheet, validation: loaded.validation };
+    }
+    const assetDir = path.join(root, id);
+    const manifestPath = path.join(assetDir, "pet.json");
+    const spritesheetPath = path.join(assetDir, "spritesheet.webp");
+    if (!fs.existsSync(manifestPath) || !fs.existsSync(spritesheetPath)) {
+        throw new Error(`Missing published builtin Petdex asset ${id} under ${root}`);
+    }
+    const asset = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+    const spritesheet = fs.readFileSync(spritesheetPath);
+    const validation = validatePetdexAssetManifest(asset, spritesheet);
+    assertBuiltinPetdexAsset(id, asset);
+    return { asset, spritesheet, validation };
+}
+function builtinPetdexAssetRoot() {
+    const configured = process.env.QLOGICAGENT_BUILTIN_PETDEX_DIR?.trim();
+    if (configured)
+        return path.resolve(configured);
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "builtin-petdex");
+}
+function assertBuiltinPetdexAsset(expectedId, asset) {
+    if (asset.id !== expectedId)
+        throw new Error(`Builtin Petdex asset id mismatch: expected ${expectedId}, got ${asset.id}`);
+    if (asset.source.kind !== "builtin")
+        throw new Error(`Builtin Petdex asset ${expectedId} must declare source.kind=builtin`);
+}
+async function normalizePetdexSpritesheet(input) {
+    const image = await loadImage(input);
+    const canvas = createCanvas(PETDEX_ATLAS_CONTRACT.width, PETDEX_ATLAS_CONTRACT.height);
+    const ctx = canvas.getContext("2d");
+    ctx.clearRect(0, 0, PETDEX_ATLAS_CONTRACT.width, PETDEX_ATLAS_CONTRACT.height);
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = "high";
+    ctx.drawImage(image, 0, 0, PETDEX_ATLAS_CONTRACT.width, PETDEX_ATLAS_CONTRACT.height);
+    return Buffer.from(await canvas.encode("webp"));
+}
+function sanitizePackageFileName(value) {
+    const sanitized = value.replace(/[^a-zA-Z0-9._-]/g, "_").replace(/^_+/, "");
+    return sanitized || "petdex-asset.petdex";
+}
+async function extractZip(buffer) {
+    const entries = new Map();
+    let offset = 0;
+    while (offset < buffer.length - 4) {
+        const sig = buffer.readUInt32LE(offset);
+        if (sig !== 0x04034b50)
+            break;
+        const compMethod = buffer.readUInt16LE(offset + 8);
+        const compSize = buffer.readUInt32LE(offset + 18);
+        const uncompSize = buffer.readUInt32LE(offset + 22);
+        const nameLen = buffer.readUInt16LE(offset + 26);
+        const extraLen = buffer.readUInt16LE(offset + 28);
+        const nameStart = offset + 30;
+        const name = buffer.subarray(nameStart, nameStart + nameLen).toString("utf-8");
+        const dataStart = nameStart + nameLen + extraLen;
+        const compressed = buffer.subarray(dataStart, dataStart + compSize);
+        if (compMethod === 0) {
+            entries.set(name, buffer.subarray(dataStart, dataStart + uncompSize));
+        }
+        else if (compMethod === 8) {
+            const { inflateRawSync } = await import("node:zlib");
+            entries.set(name, inflateRawSync(compressed));
+        }
+        offset = dataStart + compSize;
+    }
+    return entries;
+}
+function createZip(entries) {
+    const localParts = [];
+    const centralParts = [];
+    let offset = 0;
+    const { time, date } = currentDosTime();
+    for (const entry of entries) {
+        if (hasUnsafePath(entry.name))
+            throw new Error(`unsafe path in Petdex package entry: ${entry.name}`);
+        const name = Buffer.from(entry.name, "utf-8");
+        const crc = crc32(entry.data);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(0x0800, 6);
+        local.writeUInt16LE(0, 8);
+        local.writeUInt16LE(time, 10);
+        local.writeUInt16LE(date, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(entry.data.length, 18);
+        local.writeUInt32LE(entry.data.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        local.writeUInt16LE(0, 28);
+        localParts.push(local, name, entry.data);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(20, 4);
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(0x0800, 8);
+        central.writeUInt16LE(0, 10);
+        central.writeUInt16LE(time, 12);
+        central.writeUInt16LE(date, 14);
+        central.writeUInt32LE(crc, 16);
+        central.writeUInt32LE(entry.data.length, 20);
+        central.writeUInt32LE(entry.data.length, 24);
+        central.writeUInt16LE(name.length, 28);
+        central.writeUInt16LE(0, 30);
+        central.writeUInt16LE(0, 32);
+        central.writeUInt16LE(0, 34);
+        central.writeUInt16LE(0, 36);
+        central.writeUInt32LE(0, 38);
+        central.writeUInt32LE(offset, 42);
+        centralParts.push(central, name);
+        offset += local.length + name.length + entry.data.length;
+    }
+    const centralOffset = offset;
+    const centralDirectory = Buffer.concat(centralParts);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(0, 4);
+    end.writeUInt16LE(0, 6);
+    end.writeUInt16LE(entries.length, 8);
+    end.writeUInt16LE(entries.length, 10);
+    end.writeUInt32LE(centralDirectory.length, 12);
+    end.writeUInt32LE(centralOffset, 16);
+    end.writeUInt16LE(0, 20);
+    return Buffer.concat([...localParts, centralDirectory, end]);
+}
+function currentDosTime() {
+    const now = new Date();
+    const time = (now.getHours() << 11) | (now.getMinutes() << 5) | Math.floor(now.getSeconds() / 2);
+    const date = ((now.getFullYear() - 1980) << 9) | ((now.getMonth() + 1) << 5) | now.getDate();
+    return { time, date };
+}
+const CRC32_TABLE = new Uint32Array(256).map((_, index) => {
+    let value = index;
+    for (let bit = 0; bit < 8; bit++) {
+        value = (value & 1) ? (0xedb88320 ^ (value >>> 1)) : (value >>> 1);
+    }
+    return value >>> 0;
+});
+function crc32(buffer) {
+    let crc = 0xffffffff;
+    for (const byte of buffer) {
+        crc = CRC32_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}

package/dist/runtime/pet/petdex-asset.test.d.ts

@@ -0,0 +1 @@
+export {};