@tea-agent/loop-agent 0.33.6 → 0.33.7-beta.0

package/dist/worker/console/chat/pi-console-config.js

@@ -1,6 +1,8 @@
 import { createHash, randomBytes } from "node:crypto";
 import { open, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { readJsonIfExists, writeSecureJson } from "../app-data.js";
+import { OPERATOR_CHAT_ALLOWED_INSTRUCTION_SKILLS } from "./instruction-skills.js";
 const revision = (raw) => createHash("sha256").update(raw).digest("hex");
 export async function readModelsConfig(agentDir) {
     let raw = "{}";
@@ -108,219 +110,26 @@ export async function patchModelsConfig(agentDir, input) {
     await rename(tmp, file);
     return readModelsConfig(agentDir);
 }
-/** Max bytes of a package.json we are willing to read (read-only, bounded). */
-export const MAX_PACKAGE_JSON_BYTES = 64 * 1024;
-/** Max directory levels walked upward from an owned resolved resource path. */
-export const MAX_PACKAGE_JSON_WALK_DEPTH = 24;
-/**
- * One npm-style range token: optional comparator/v-prefix followed by an
- * exact/x-form version, a wildcard, or a prerelease/build suffix. Accepts
- * >=2.0.0, <3.0.0, ^2.1.0, ~1.2.3, ~1, 1.2, 1.x, 1.2.x, 1.2.3-beta.1+build.5, *.
- */
-const SPEC_RANGE_TOKEN = "(?:>=|<=|[<>=~^*v])?(?:\\d+(?:\\.(?:\\d+|x|X)){0,2}(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?|\\*|x|X)";
-/** Whitespace-separated comparator list, e.g. ">=2.0.0 <3.0.0". */
-const SPEC_RANGE = new RegExp(`^${SPEC_RANGE_TOKEN}(?:\\s+${SPEC_RANGE_TOKEN})*$`);
-/**
- * Installed-side grammar: an EXACT semver with optional prerelease and build
- * metadata (1.2.3, 1.2.3-beta.1, 1.2.3+build.5, 1.2.3-beta.1+build.5). Ranges
- * and partial shapes (*, 1.x, ~1, 1.2) are rejected with a field diagnostic.
- */
-const INSTALLED_VERSION = /^v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
-/**
- * Try to derive the explicit version/range from an npm-style spec — verbatim
- * projection, zero resolution and zero install (AC-RF-1). Git/URL shapes
- * (containing /, #, :// or git+) never project a configuredVersion.
- */
-function versionFromSpec(spec) {
-    // npm:name@1.2.3 / name@^1.2 / @scope/name@1.2.3 — never guess on git/url specs.
-    const match = spec.match(/^(?:npm:)?(@?[^@/\s]+(?:\/[^@\s]+)?)@(.+)$/);
-    if (!match)
-        return undefined;
-    const version = match[2];
-    if (/[\/#:]|git\+/.test(version))
-        return undefined;
-    return SPEC_RANGE.test(version) ? version : undefined;
+const preferencesFile = (appData) => path.join(appData.chats, ".instruction-skill-preferences.json");
+export async function readSkillPreferences(appData) {
+    const value = await readJsonIfExists(preferencesFile(appData));
+    return (value?.disabledNames ?? []).filter((name) => OPERATOR_CHAT_ALLOWED_INSTRUCTION_SKILLS.includes(name));
 }
-/**
- * Bounded read of a package.json: open + single read capped at
- * MAX_PACKAGE_JSON_BYTES+1 so an oversized file is detected without
- * buffering the whole file, then JSON.parse with root-object validation.
- */
-async function readPackageJsonBounded(file) {
-    let handle;
-    try {
-        handle = await open(file, "r");
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === "ENOENT")
-            return { ok: false, missing: true, diagnostic: "" };
-        return {
-            ok: false,
-            diagnostic: `PACKAGE_JSON_READ_FAILED: ${file} (${error instanceof Error ? error.message : String(error)})`,
-        };
-    }
-    try {
-        const buffer = Buffer.alloc(MAX_PACKAGE_JSON_BYTES + 1);
-        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-        if (bytesRead > MAX_PACKAGE_JSON_BYTES) {
-            return {
-                ok: false,
-                diagnostic: `PACKAGE_JSON_TOO_LARGE: ${file} (exceeds ${MAX_PACKAGE_JSON_BYTES} bytes)`,
-            };
-        }
-        const raw = buffer.subarray(0, bytesRead).toString("utf8");
-        let parsed;
-        try {
-            parsed = JSON.parse(raw);
-        }
-        catch (error) {
-            return {
-                ok: false,
-                diagnostic: `PACKAGE_JSON_INVALID: ${file} (${error instanceof Error ? error.message : String(error)})`,
-            };
-        }
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-            return {
-                ok: false,
-                diagnostic: `PACKAGE_JSON_INVALID: ${file} (root must be a JSON object)`,
-            };
-        }
-        const record = parsed;
-        return { ok: true, value: { name: record.name, version: record.version } };
-    }
-    finally {
-        await handle.close().catch(() => { });
-    }
-}
-/**
- * Owning npm package root for a resolved entry directory: the deepest
- * ancestor BELOW the nearest node_modules directory (scoped:
- * node_modules/@scope/<pkg>). Returns undefined when the entry is not inside
- * any node_modules boundary — readOwnedPackageJson then degrades with
- * PACKAGE_JSON_NOT_FOUND instead of walking to an ancestor manifest.
- */
-function packageBoundaryRoot(startDir) {
-    let dir = startDir;
-    for (let depth = 0; depth < MAX_PACKAGE_JSON_WALK_DEPTH; depth += 1) {
-        if (path.basename(dir) === "node_modules") {
-            const segments = path
-                .relative(dir, startDir)
-                .split(path.sep)
-                .filter((segment) => segment.length > 0);
-            if (segments.length === 0)
-                return dir;
-            if (segments[0].startsWith("@") && segments.length >= 2) {
-                return path.join(dir, segments[0], segments[1]);
-            }
-            return path.join(dir, segments[0]);
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return undefined;
-        dir = parent;
-    }
-    return undefined;
-}
-/**
- * Walk UP from an owned resolved resource path (bounded, separator-normalized)
- * to the NEAREST package.json within the owning npm package boundary and
- * project its validated metadata. The walk NEVER crosses the package root
- * (node_modules/<pkg> or node_modules/@scope/<pkg>): a missing manifest there
- * yields PACKAGE_JSON_NOT_FOUND instead of mis-attributing an ancestor
- * workspace manifest (AC-RF-3). Missing name/version fields yield per-field
- * PACKAGE_JSON_FIELD_INVALID diagnostics and suppress the whole metadata trio
- * (AC-RF-4). Corrupt / oversized / invalid-field reads stop at that nearest
- * package.json with a per-package diagnostic. Empty paths never probe the
- * filesystem.
- */
-async function readOwnedPackageJson(entryPath) {
-    if (!entryPath)
-        return { ok: false, diagnostics: [] };
-    const normalized = entryPath.replace(/[\\/]+/g, path.sep);
-    const startDir = path.dirname(normalized);
-    const boundaryRoot = packageBoundaryRoot(startDir);
-    if (boundaryRoot === undefined) {
-        // No legal node_modules/<pkg> or node_modules/@scope/<pkg> boundary:
-        // never walk to (or accept) an ancestor manifest (AC-B1/AC-B2).
-        return {
-            ok: false,
-            diagnostics: [
-                `PACKAGE_JSON_NOT_FOUND: ${startDir} (resolved resource is not inside a legal node_modules package boundary)`,
-            ],
-        };
-    }
-    let dir = startDir;
-    for (let depth = 0; depth < MAX_PACKAGE_JSON_WALK_DEPTH; depth += 1) {
-        const file = path.join(dir, "package.json");
-        const read = await readPackageJsonBounded(file);
-        if (read.ok) {
-            const { name, version } = read.value;
-            const meta = { installedPath: dir };
-            const fieldDiagnostics = [];
-            if (name === undefined) {
-                fieldDiagnostics.push(`PACKAGE_JSON_FIELD_INVALID: ${file} (missing name)`);
-            }
-            else if (typeof name !== "string" ||
-                name.trim().length === 0 ||
-                name.length > 214) {
-                fieldDiagnostics.push(`PACKAGE_JSON_FIELD_INVALID: ${file} (name must be a non-empty string ≤ 214 chars)`);
-            }
-            else {
-                meta.packageName = name;
-            }
-            if (version === undefined) {
-                fieldDiagnostics.push(`PACKAGE_JSON_FIELD_INVALID: ${file} (missing version)`);
-            }
-            else if (typeof version !== "string" || !INSTALLED_VERSION.test(version)) {
-                // Type + format validation only: the browser projection (80-char limit)
-                // is the single truncation authority for versions (AC-8 reuse chain).
-                fieldDiagnostics.push(`PACKAGE_JSON_FIELD_INVALID: ${file} (version must be an exact semver string)`);
-            }
-            else {
-                meta.version = version;
-            }
-            if (name === undefined || version === undefined) {
-                // A manifest missing a required field cannot prove package ownership:
-                // none of packageName/version/installedPath is projected (AC-RF-4).
-                return { ok: false, diagnostics: fieldDiagnostics };
-            }
-            return {
-                ok: true,
-                meta,
-                ...(fieldDiagnostics.length > 0
-                    ? { diagnostics: fieldDiagnostics }
-                    : {}),
-            };
-        }
-        // Missing file (ENOENT): keep walking up the owned chain, but never past
-        // the owning package root. Any other read/parse failure means the nearest
-        // package.json IS the package boundary — degrade only this package and
-        // stop (AC-5).
-        if (read.missing !== true) {
-            return { ok: false, diagnostics: [read.diagnostic] };
-        }
-        if (boundaryRoot !== undefined && dir === boundaryRoot) {
-            return {
-                ok: false,
-                diagnostics: [
-                    `PACKAGE_JSON_NOT_FOUND: ${dir} (no package.json within the owning npm package boundary)`,
-                ],
-            };
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return {
-        ok: false,
-        diagnostics: [
-            `PACKAGE_JSON_NOT_FOUND: ${startDir} (no package.json on the resolved resource chain)`,
-        ],
-    };
+export async function writeSkillPreferences(appData, disabledNames) {
+    const allowed = new Set(OPERATOR_CHAT_ALLOWED_INSTRUCTION_SKILLS);
+    if (disabledNames.some((name) => !allowed.has(name)))
+        throw Object.assign(new Error("preferences contain a non-allowed skill"), {
+            code: "INVALID_INPUT",
+            status: 400,
+        });
+    const normalized = [...new Set(disabledNames)].sort();
+    await writeSecureJson(preferencesFile(appData), {
+        schemaVersion: 1,
+        disabledNames: normalized,
+    });
+    return normalized;
 }
-export async function readPackageInventory(agentDir, repoRoot, resolved) {
+export async function readPackageInventory(agentDir, repoRoot) {
     const read = async (file) => {
         try {
             const parsed = JSON.parse(await readFile(file, "utf8"));
@@ -332,45 +141,18 @@ export async function readPackageInventory(agentDir, repoRoot, resolved) {
     };
     const global = await read(path.join(agentDir, "settings.json"));
     const project = await read(path.join(repoRoot, ".pi", "settings.json"));
-    const specs = [
-        ...global.map((spec) => ({ spec, scope: "global" })),
-        ...project.map((spec) => ({ spec, scope: "project" })),
-    ];
-    const entries = [];
-    for (const { spec, scope } of specs) {
-        // A resource belongs to this package when its source matches the spec
-        // exactly or ends with it (e.g. package subpath sources).
-        const owned = (resolved ?? []).filter((item) => item.source === spec || item.source.endsWith(`/${spec}`));
-        const diagnostics = owned
-            .map((item) => item.scope === "temporary" ? `temporary scope: ${item.path}` : "")
-            .filter(Boolean);
-        // No owned resources → no filesystem probing at all (AC-1): the optional
-        // metadata fields stay absent and only the always-projected cwd is added.
-        const meta = owned.length > 0 && owned[0]?.path
-            ? await readOwnedPackageJson(owned[0].path)
-            : { ok: true, meta: undefined, diagnostics: [] };
-        if (meta.diagnostics)
-            diagnostics.push(...meta.diagnostics);
-        entries.push({
+    return [
+        ...global.map((spec) => ({
             spec,
-            scope,
+            scope: "global",
             enabled: true,
-            cwd: repoRoot,
-            ...(versionFromSpec(spec)
-                ? { configuredVersion: versionFromSpec(spec) }
-                : {}),
-            ...(meta.ok && meta.meta?.packageName
-                ? { packageName: meta.meta.packageName }
-                : {}),
-            ...(meta.ok && meta.meta?.version ? { version: meta.meta.version } : {}),
-            ...(meta.ok && meta.meta?.installedPath
-                ? { installedPath: meta.meta.installedPath }
-                : {}),
-            ...(owned[0]?.path ? { path: owned[0].path } : {}),
-            resolved: owned,
-            resourceCount: owned.length,
-            diagnostics,
-        });
-    }
-    return entries;
+            resourceCount: 0,
+        })),
+        ...project.map((spec) => ({
+            spec,
+            scope: "project",
+            enabled: true,
+            resourceCount: 0,
+        })),
+    ];
 }