@tea-agent/loop-agent 0.34.2 → 0.34.4

package/dist/worker/console/chat/resource-preferences-store.js

@@ -0,0 +1,152 @@
+/**
+ * Operator Chat — repo-scoped resource auto-invocation preferences.
+ *
+ * Persists under Console app-data `resource-preferences.json` (per repo
+ * fingerprint). Preferences never touch SKILL.md, Pi settings, or tracked repo
+ * files. Malformed on-disk data fails closed.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync } from "node:fs";
+import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+export const RESOURCE_PREFERENCES_SCHEMA_VERSION = 1;
+export class ResourcePreferencesError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ResourcePreferencesError";
+        this.code = code;
+    }
+}
+/** Stable server-issued resource id for a discovered skill (path + name). */
+export function skillResourceId(skill) {
+    return createHash("sha256")
+        .update(`skill\0${skill.name}\0${skill.filePath}`, "utf8")
+        .digest("hex")
+        .slice(0, 32);
+}
+function emptyPreferences() {
+    return {
+        schemaVersion: RESOURCE_PREFERENCES_SCHEMA_VERSION,
+        skills: {},
+    };
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Parse and validate on-disk preferences. Malformed content fails closed with
+ * a structured error (never silently treated as empty-success).
+ */
+export function parseResourcePreferences(raw) {
+    if (raw === undefined)
+        return emptyPreferences();
+    if (!isPlainObject(raw)) {
+        throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", "resource-preferences.json must be a JSON object");
+    }
+    if (raw.schemaVersion !== RESOURCE_PREFERENCES_SCHEMA_VERSION) {
+        throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", `unsupported resource-preferences schemaVersion: ${String(raw.schemaVersion)}`);
+    }
+    if (!isPlainObject(raw.skills)) {
+        throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", "resource-preferences.skills must be an object");
+    }
+    const skills = {};
+    for (const [resourceId, entry] of Object.entries(raw.skills)) {
+        if (typeof resourceId !== "string" || !resourceId.trim()) {
+            throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", "resource-preferences skill key must be a non-empty string");
+        }
+        if (!isPlainObject(entry)) {
+            throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", `resource-preferences entry for ${resourceId} must be an object`);
+        }
+        if (typeof entry.autoInvocationEnabled !== "boolean") {
+            throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", `resource-preferences entry for ${resourceId} missing boolean autoInvocationEnabled`);
+        }
+        if (typeof entry.updatedAt !== "string" || !entry.updatedAt.trim()) {
+            throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", `resource-preferences entry for ${resourceId} missing updatedAt`);
+        }
+        skills[resourceId] = {
+            autoInvocationEnabled: entry.autoInvocationEnabled,
+            updatedAt: entry.updatedAt,
+        };
+    }
+    return {
+        schemaVersion: RESOURCE_PREFERENCES_SCHEMA_VERSION,
+        skills,
+    };
+}
+export async function loadResourcePreferences(filePath) {
+    if (!filePath)
+        return emptyPreferences();
+    if (existsSync(filePath)) {
+        const st = lstatSync(filePath);
+        if (st.isSymbolicLink() || !st.isFile()) {
+            throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", `refusing to read non-regular resource-preferences file: ${filePath}`);
+        }
+    }
+    let raw;
+    try {
+        raw = await readJsonIfExists(filePath);
+    }
+    catch (error) {
+        throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", error instanceof Error ? error.message : String(error));
+    }
+    return parseResourcePreferences(raw);
+}
+/** resourceIds whose auto-invocation is explicitly disabled (default = enabled). */
+export function disabledAutoInvocationIds(prefs) {
+    const disabled = new Set();
+    for (const [id, entry] of Object.entries(prefs.skills)) {
+        if (entry.autoInvocationEnabled === false)
+            disabled.add(id);
+    }
+    return disabled;
+}
+export function isAutoInvocationEnabled(prefs, resourceId) {
+    const entry = prefs.skills[resourceId];
+    if (!entry)
+        return true;
+    return entry.autoInvocationEnabled !== false;
+}
+export async function setSkillAutoInvocationPreference(options) {
+    const current = await loadResourcePreferences(options.filePath);
+    const next = {
+        schemaVersion: RESOURCE_PREFERENCES_SCHEMA_VERSION,
+        skills: {
+            ...current.skills,
+            [options.resourceId]: {
+                autoInvocationEnabled: options.autoInvocationEnabled,
+                updatedAt: options.now ?? new Date().toISOString(),
+            },
+        },
+    };
+    // Default-on entries may be pruned to keep the file sparse when re-enabled.
+    if (options.autoInvocationEnabled === true) {
+        // Keep explicit true only when previously present was false; either way
+        // store the affirmative so UI/history can show last toggle time.
+    }
+    try {
+        await writeSecureJson(options.filePath, next);
+    }
+    catch (error) {
+        throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_WRITE_FAILED", error instanceof Error ? error.message : String(error));
+    }
+    return next;
+}
+/**
+ * Apply stored auto-invocation preferences onto a discovered skill list.
+ * Skills remain in inventory (manual /skill:name stays available); only
+ * `disableModelInvocation` is forced true when the preference is off.
+ * Existing frontmatter disableModelInvocation is never cleared.
+ */
+export function applySkillAutoInvocationPreferences(skills, prefs) {
+    const disabled = disabledAutoInvocationIds(prefs);
+    if (disabled.size === 0)
+        return skills;
+    return skills.map((skill) => {
+        const id = skillResourceId(skill);
+        if (!disabled.has(id))
+            return skill;
+        if (skill.disableModelInvocation === true)
+            return skill;
+        return { ...skill, disableModelInvocation: true };
+    });
+}