@tea-agent/loop-agent 0.43.0-next.1 → 0.43.0-next.11

package/dist/worker/console/chat/pi-runtime/inspection.js

@@ -0,0 +1,439 @@
+/**
+ * Runtime inspection: browser-safe snapshot projection, slash-command
+ * inventory, and ResourceLoader/package/MCP collection. Does not own
+ * session lifecycle, preference-file cache, or prompt/reload locks.
+ */
+import { RUNTIME_CONTEXT_TEXT_MAX, redactRuntimeText, } from "../runtime-context.js";
+import { isAutoInvocationEnabled, skillResourceId, } from "../resource-preferences-store.js";
+/**
+ * Browser-safe projection of a live runtime snapshot (design §2.2 / RF-03).
+ *
+ * Every browser-visible string runs the shared secret-scrub chain
+ * (scrubSecrets + ghp_/Bearer redaction via redactRuntimeText) and a fixed
+ * per-field length limit: 200 (names/spec/source/origin), 400 (paths/errors/
+ * diagnostic messages), 600 (skill descriptions), 80 (package versions);
+ * truncation uses the fixed `…[truncated N chars …]` marker. The server-only
+ * `raw` prompt and the RAW-based `sha256`/`characters` pass through untouched,
+ * and real empty lists stay empty.
+ *
+ * Pure + deterministic and exported so the route harness reuses the exact
+ * production implementation (same code path as getRuntimeSnapshot).
+ */
+export function projectRuntimeSnapshot(input) {
+    const field = (value, max) => value === undefined ? undefined : redactRuntimeText(value, max);
+    const projectSkill = (skill) => ({
+        name: field(skill.name, 200) ?? "",
+        description: field(skill.description, 600) ?? "",
+        path: field(skill.path, 400) ?? "",
+        ...(skill.baseDir ? { baseDir: field(skill.baseDir, 400) } : {}),
+        scope: skill.scope,
+        source: field(skill.source, 200) ?? "",
+        resourceId: field(skill.resourceId, 200) ?? "",
+        autoInvocationEnabled: skill.autoInvocationEnabled,
+        diagnostics: skill.diagnostics.map((diag) => field(diag, 400) ?? ""),
+    });
+    const projectExtension = (ext) => ({
+        name: field(ext.name, 200) ?? "",
+        path: field(ext.path, 400) ?? "",
+        ...(ext.resolvedPath
+            ? { resolvedPath: field(ext.resolvedPath, 400) }
+            : {}),
+        source: field(ext.source, 200) ?? "",
+        scope: ext.scope,
+        ...(ext.origin ? { origin: field(ext.origin, 200) } : {}),
+        enabled: ext.enabled,
+        ...(ext.error ? { error: field(ext.error, 400) } : {}),
+    });
+    const projectPackage = (pkg) => ({
+        spec: field(pkg.spec, 200) ?? "",
+        scope: pkg.scope,
+        enabled: pkg.enabled,
+        ...(pkg.version ? { version: field(pkg.version, 80) } : {}),
+        ...(pkg.configuredVersion
+            ? { configuredVersion: field(pkg.configuredVersion, 80) }
+            : {}),
+        ...(pkg.packageName ? { packageName: field(pkg.packageName, 200) } : {}),
+        ...(pkg.path ? { path: field(pkg.path, 400) } : {}),
+        ...(pkg.installedPath ? { installedPath: field(pkg.installedPath, 400) } : {}),
+        ...(pkg.cwd ? { cwd: field(pkg.cwd, 400) } : {}),
+        resolved: pkg.resolved.map((resource) => ({
+            type: resource.type,
+            name: field(resource.name, 200) ?? "",
+            path: field(resource.path, 400) ?? "",
+            source: field(resource.source, 200) ?? "",
+            scope: resource.scope,
+        })),
+        diagnostics: pkg.diagnostics.map((diag) => field(diag, 400) ?? ""),
+    });
+    const projectMcpTool = (tool) => ({
+        name: field(tool.name, 200) ?? "",
+        description: field(tool.description, 600) ?? "",
+        ...(tool.server ? { server: field(tool.server, 200) } : {}),
+        source: field(tool.source, 200) ?? "",
+        scope: tool.scope,
+        ...(tool.path ? { path: field(tool.path, 400) } : {}),
+        active: tool.active,
+    });
+    const projectMcp = (mcp) => ({
+        servers: mcp.servers.map((server) => ({
+            name: field(server.name, 200) ?? "",
+            scope: server.scope,
+            status: server.status,
+            enabled: server.enabled,
+            ...(server.transport ? { transport: field(server.transport, 80) } : {}),
+            ...(server.command ? { command: field(server.command, 400) } : {}),
+            ...(server.url ? { url: field(server.url, 400) } : {}),
+            ...(server.configPath ? { configPath: field(server.configPath, 400) } : {}),
+            tools: server.tools.map(projectMcpTool),
+        })),
+        unassignedTools: mcp.unassignedTools.map(projectMcpTool),
+    });
+    const projectDiagnostic = (diag) => ({
+        type: diag.type,
+        ...(diag.code ? { code: diag.code } : {}),
+        message: field(diag.message, 400) ?? "",
+        ...(diag.path ? { path: field(diag.path, 400) } : {}),
+        ...(diag.retryable !== undefined
+            ? { retryable: diag.retryable }
+            : {}),
+    });
+    return {
+        sessionId: input.sessionId,
+        revision: input.revision,
+        loadedAt: input.loadedAt,
+        selection: {
+            ...(input.selection.model
+                ? {
+                    model: {
+                        provider: input.selection.model.provider,
+                        id: input.selection.model.id,
+                        ...(input.selection.model.name
+                            ? { name: field(input.selection.model.name, 200) }
+                            : {}),
+                    },
+                }
+                : {}),
+            thinkingSelection: input.selection.thinkingSelection,
+            ...(input.selection.effectiveThinkingLevel
+                ? { effectiveThinkingLevel: input.selection.effectiveThinkingLevel }
+                : {}),
+        },
+        models: input.models.map((model) => ({
+            provider: model.provider,
+            id: model.id,
+            ...(model.name ? { name: field(model.name, 200) } : {}),
+            ...(model.hasCredentials !== undefined
+                ? { hasCredentials: model.hasCredentials }
+                : {}),
+        })),
+        thinkingLevels: input.thinkingLevels.map((option) => ({ ...option })),
+        systemPrompt: {
+            ...(input.systemPrompt.raw !== undefined
+                ? { raw: input.systemPrompt.raw }
+                : {}),
+            text: redactRuntimeText(input.systemPrompt.text, RUNTIME_CONTEXT_TEXT_MAX),
+            sha256: input.systemPrompt.sha256,
+            characters: input.systemPrompt.characters,
+        },
+        activeTools: [...input.activeTools],
+        contextFiles: input.contextFiles.map((file) => ({
+            path: field(file.path, 400) ?? "",
+            characters: file.characters,
+        })),
+        skills: input.skills.map(projectSkill),
+        extensions: input.extensions.map(projectExtension),
+        packages: input.packages.map(projectPackage),
+        mcp: projectMcp(input.mcp ?? { servers: [], unassignedTools: [] }),
+        diagnostics: input.diagnostics.map(projectDiagnostic),
+        hasBash: input.hasBash,
+    };
+}
+/**
+ * Browser-safe slash command projection for UI-11.
+ * Sources: current Session extension commands, prompt templates, skills.
+ * Never returns prompt/skill file bodies. Same-name conflict priority:
+ * extension > skill > prompt.
+ */
+export function collectSlashCommands(input) {
+    const scrub = (value) => {
+        const raw = String(value ?? "");
+        return raw
+            .replace(/\/Users\/[^\s]+/gi, "~")
+            .replace(/[A-Za-z]:\\Users\\[^\s]+/gi, "~")
+            .slice(0, 240);
+    };
+    const session = input.session;
+    if (!session)
+        return { commands: [] };
+    const SOURCE_RANK = {
+        extension: 0,
+        skill: 1,
+        prompt: 2,
+    };
+    const byKey = new Map();
+    const sourceWarnings = [];
+    const push = (command, label, description, source) => {
+        const name = command.startsWith("/") ? command : `/${command}`;
+        const key = name.toLowerCase();
+        if (!key || key === "/")
+            return;
+        const next = {
+            command: name,
+            label: (label || name).slice(0, 80),
+            description: scrub(description),
+            source,
+        };
+        const existing = byKey.get(key);
+        if (!existing || SOURCE_RANK[source] < SOURCE_RANK[existing.source]) {
+            byKey.set(key, next);
+        }
+    };
+    try {
+        const cmds = session.extensionRunner?.getRegisteredCommands?.() ?? [];
+        for (const cmd of cmds) {
+            const name = cmd.invocationName || cmd.name;
+            if (!name)
+                continue;
+            push(String(name), String(cmd.name || name), String(cmd.description || ""), "extension");
+        }
+    }
+    catch (error) {
+        sourceWarnings.push(`extension: ${scrub(error instanceof Error ? error.message : String(error))}`);
+    }
+    try {
+        for (const tpl of session.promptTemplates ?? []) {
+            if (!tpl?.name)
+                continue;
+            push(String(tpl.name), String(tpl.name), String(tpl.description || ""), "prompt");
+        }
+    }
+    catch (error) {
+        sourceWarnings.push(`prompt: ${scrub(error instanceof Error ? error.message : String(error))}`);
+    }
+    try {
+        const skills = input.resourceLoader?.getSkills?.()?.skills ?? [];
+        for (const skill of skills) {
+            if (!skill?.name)
+                continue;
+            const command = skill.name.startsWith("skill:")
+                ? `/${skill.name}`
+                : `/skill:${skill.name}`;
+            push(command, skill.name, String(skill.description || ""), "skill");
+        }
+    }
+    catch (error) {
+        sourceWarnings.push(`skill: ${scrub(error instanceof Error ? error.message : String(error))}`);
+    }
+    const warning = sourceWarnings.length > 0
+        ? sourceWarnings.join("; ").slice(0, 160)
+        : undefined;
+    return {
+        commands: [...byKey.values()],
+        ...(warning ? { warning } : {}),
+    };
+}
+/**
+ * Collect ResourceLoader / package / MCP inventories for a live session.
+ * Preference-file loading stays with ConsolePiRuntime; this function only
+ * consumes already-loaded prefs (or a captured load error).
+ */
+export async function collectRuntimeInventories(input) {
+    const contextFiles = [];
+    const skills = [];
+    const extensions = [];
+    const diagnostics = [];
+    const resolvedResources = [];
+    const resourceFailure = (subface, error) => {
+        diagnostics.push({
+            type: "error",
+            code: "RESOURCE_LOAD_FAILED",
+            message: `${subface} inventory failed: ${error instanceof Error ? error.message : String(error)}`,
+            retryable: true,
+        });
+    };
+    if (input.skillPrefsError !== undefined) {
+        diagnostics.push({
+            type: "error",
+            code: "PI_RESOURCE_PREFERENCES_MALFORMED",
+            message: input.skillPrefsError instanceof Error
+                ? input.skillPrefsError.message
+                : String(input.skillPrefsError),
+            retryable: true,
+        });
+    }
+    const resourceLoader = input.resourceLoader;
+    if (resourceLoader) {
+        try {
+            const agentsFiles = resourceLoader.getAgentsFiles?.();
+            for (const file of agentsFiles?.agentsFiles ?? []) {
+                if (!file.path)
+                    continue;
+                contextFiles.push({
+                    path: file.path,
+                    characters: file.content?.length ?? 0,
+                });
+            }
+        }
+        catch (error) {
+            resourceFailure("context files", error);
+        }
+        try {
+            const skillsResult = resourceLoader.getSkills?.();
+            for (const skill of skillsResult?.skills ?? []) {
+                const resourceId = skillResourceId({
+                    name: skill.name,
+                    filePath: skill.filePath,
+                });
+                const prefEnabled = isAutoInvocationEnabled(input.skillPrefs, resourceId);
+                const autoInvocationEnabled = prefEnabled && skill.disableModelInvocation !== true;
+                skills.push({
+                    name: skill.name,
+                    description: skill.description ?? "",
+                    path: skill.filePath,
+                    ...(skill.baseDir ? { baseDir: skill.baseDir } : {}),
+                    scope: skill.sourceInfo?.scope ?? "unknown",
+                    source: skill.sourceInfo?.source ?? "",
+                    resourceId,
+                    autoInvocationEnabled,
+                    diagnostics: [],
+                });
+                resolvedResources.push({
+                    type: "skill",
+                    name: skill.name,
+                    path: skill.filePath,
+                    source: skill.sourceInfo?.source ?? "",
+                    scope: skill.sourceInfo?.scope ?? "unknown",
+                });
+            }
+            for (const diag of skillsResult?.diagnostics ?? []) {
+                if (!diag?.message)
+                    continue;
+                diagnostics.push({
+                    type: diag.type ?? "warning",
+                    message: diag.message,
+                    ...(diag.path ? { path: diag.path } : {}),
+                });
+            }
+        }
+        catch (error) {
+            resourceFailure("skills", error);
+        }
+        try {
+            const extResult = resourceLoader.getExtensions?.();
+            for (const ext of extResult?.extensions ?? []) {
+                const path = ext.resolvedPath ?? ext.path ?? "";
+                extensions.push({
+                    name: ext.sourceInfo?.source ?? ext.path ?? "extension",
+                    path,
+                    ...(ext.resolvedPath ? { resolvedPath: ext.resolvedPath } : {}),
+                    source: ext.sourceInfo?.source ?? "",
+                    scope: ext.sourceInfo?.scope ?? "unknown",
+                    ...(ext.sourceInfo?.origin ? { origin: ext.sourceInfo.origin } : {}),
+                    enabled: true,
+                });
+                resolvedResources.push({
+                    type: "extension",
+                    name: ext.sourceInfo?.source ?? ext.path ?? "extension",
+                    path,
+                    source: ext.sourceInfo?.source ?? "",
+                    scope: ext.sourceInfo?.scope ?? "unknown",
+                });
+            }
+            for (const err of extResult?.errors ?? []) {
+                if (!err?.error)
+                    continue;
+                diagnostics.push({
+                    type: "error",
+                    message: err.error,
+                    ...(err.path ? { path: err.path } : {}),
+                });
+            }
+        }
+        catch (error) {
+            resourceFailure("extensions", error);
+        }
+        try {
+            const promptsResult = resourceLoader.getPrompts?.();
+            for (const prompt of promptsResult?.prompts ?? []) {
+                resolvedResources.push({
+                    type: "prompt",
+                    name: prompt.name,
+                    path: prompt.filePath,
+                    source: prompt.sourceInfo?.source ?? "",
+                    scope: prompt.sourceInfo?.scope ?? "unknown",
+                });
+            }
+            for (const diag of promptsResult?.diagnostics ?? []) {
+                if (!diag?.message)
+                    continue;
+                diagnostics.push({
+                    type: diag.type ?? "warning",
+                    message: diag.message,
+                    ...(diag.path ? { path: diag.path } : {}),
+                });
+            }
+        }
+        catch (error) {
+            resourceFailure("prompts", error);
+        }
+        try {
+            const themesResult = resourceLoader.getThemes?.();
+            for (const theme of themesResult?.themes ?? []) {
+                if (!theme.path)
+                    continue;
+                resolvedResources.push({
+                    type: "theme",
+                    name: theme.name ?? theme.path,
+                    path: theme.path,
+                    source: "",
+                    scope: "unknown",
+                });
+            }
+            for (const diag of themesResult?.diagnostics ?? []) {
+                if (!diag?.message)
+                    continue;
+                diagnostics.push({
+                    type: diag.type ?? "warning",
+                    message: diag.message,
+                    ...(diag.path ? { path: diag.path } : {}),
+                });
+            }
+        }
+        catch (error) {
+            resourceFailure("themes", error);
+        }
+    }
+    const { readPackageInventory } = await import("../pi-console-config.js");
+    let packages = [];
+    try {
+        packages = (await readPackageInventory(input.agentDir, input.cwd, resolvedResources));
+    }
+    catch (error) {
+        packages = [];
+        diagnostics.push({
+            type: "error",
+            code: "PACKAGE_INVENTORY_FAILED",
+            message: error instanceof Error ? error.message : String(error),
+            retryable: true,
+        });
+    }
+    const { readMcpInventory } = await import("../mcp-inventory.js");
+    let mcp = { servers: [], unassignedTools: [] };
+    try {
+        mcp = await readMcpInventory({
+            agentDir: input.agentDir,
+            cwd: input.cwd,
+            tools: (Array.isArray(input.tools) ? input.tools : []),
+            activeToolNames: input.activeToolNames,
+        });
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "error",
+            code: "MCP_INVENTORY_FAILED",
+            message: error instanceof Error ? error.message : String(error),
+            retryable: true,
+        });
+    }
+    return { contextFiles, skills, extensions, packages, mcp, diagnostics };
+}

package/dist/worker/console/chat/pi-runtime/sdk-bindings.js

@@ -0,0 +1,153 @@
+/**
+ * Concrete Pi SDK adapter for Console Chat. Lazy-loads the ESM SDK and
+ * implements session-file safety (wx/0600, missing-file fail-closed).
+ */
+import { access, mkdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+export async function safeGetAgentDir(bindings) {
+    try {
+        return await bindings.getAgentDir();
+    }
+    catch {
+        // Fall back to a Console-app-data scoped agent dir so we never accidentally
+        // touch the user's real ~/.pi/agent config if getAgentDir throws.
+        return path.join(process.cwd(), ".harness", "console", "pi-agent-dir");
+    }
+}
+/**
+ * Cached SDK module loader. The pi-coding-agent package is ESM-only, so we
+ * must use dynamic import() (not require). Cached to avoid repeated imports.
+ */
+let cachedSdk;
+async function loadSdk() {
+    if (!cachedSdk) {
+        cachedSdk = import("@earendil-works/pi-coding-agent");
+    }
+    return cachedSdk;
+}
+/**
+ * Default production bindings backed by the real Pi SDK (services mode).
+ * Dynamically imported so the worker bundle does not hard-fail if the SDK is
+ * absent at module load (discovered lazily by pi-readiness instead).
+ */
+export function createDefaultPiSdkBindings() {
+    return {
+        getAgentDir: async () => {
+            const sdk = (await loadSdk());
+            return sdk.getAgentDir();
+        },
+        createServices: async (opts) => {
+            const sdk = (await loadSdk());
+            // createAgentSessionServices returns the full AgentSessionServices object
+            // directly (cwd/agentDir/modelRuntime/settingsManager/resourceLoader).
+            // Wrap it so our type contract is satisfied.
+            const result = await sdk.createAgentSessionServices({
+                cwd: opts.cwd,
+                agentDir: opts.agentDir,
+                resourceLoaderOptions: opts.resourceLoaderOptions,
+            });
+            return { services: result };
+        },
+        createSessionFromServices: async (opts) => {
+            const sdk = (await loadSdk());
+            return sdk.createAgentSessionFromServices({
+                services: opts.services,
+                sessionManager: opts.sessionManager,
+                ...(opts.tools ? { tools: opts.tools } : {}),
+                ...(opts.noTools ? { noTools: opts.noTools } : {}),
+                ...(opts.excludeTools ? { excludeTools: opts.excludeTools } : {}),
+                ...(opts.customTools ? { customTools: opts.customTools } : {}),
+                ...(opts.model ? { model: opts.model } : {}),
+            });
+        },
+        createSessionManager: async (opts) => {
+            const sdk = (await loadSdk());
+            return sdk.SessionManager.create(opts.cwd, opts.sessionDir, {
+                id: opts.sessionId,
+            });
+        },
+        materializeSessionShell: async (opts) => {
+            const sdk = (await loadSdk());
+            const manager = opts.sessionManager;
+            if (typeof manager.setSessionFile !== "function") {
+                throw new Error("Pi SessionManager cannot materialize a session file");
+            }
+            let created = false;
+            try {
+                await mkdir(path.dirname(opts.sessionFile), { recursive: true });
+                // Match Pi's documented session header. Rebinding through the public
+                // SessionManager API marks it flushed, so Pi appends the first user
+                // entry instead of trying to create the already-present file later.
+                await writeFile(opts.sessionFile, `${JSON.stringify({
+                    type: "session",
+                    version: typeof sdk.CURRENT_SESSION_VERSION === "number"
+                        ? sdk.CURRENT_SESSION_VERSION
+                        : 3,
+                    id: opts.sessionId,
+                    timestamp: new Date().toISOString(),
+                    cwd: opts.cwd,
+                })}\n`, { encoding: "utf8", flag: "wx", mode: 0o600 });
+                created = true;
+                manager.setSessionFile(opts.sessionFile);
+            }
+            catch (error) {
+                if (created)
+                    await rm(opts.sessionFile, { force: true }).catch(() => undefined);
+                throw error;
+            }
+        },
+        createInMemorySessionManager: async (opts) => {
+            const sdk = (await loadSdk());
+            return sdk.SessionManager.inMemory(opts.cwd);
+        },
+        forkSessionManager: async (opts) => {
+            const sdk = (await loadSdk());
+            return sdk.SessionManager.forkFrom(opts.sourcePath, opts.targetCwd, opts.targetSessionDir, { id: opts.targetSessionId });
+        },
+        openSessionManager: async (opts) => {
+            const sdk = (await loadSdk());
+            try {
+                // Pi SessionManager.open(missingPath) does NOT throw — it creates a
+                // fresh in-memory session with a random UUID. That would reopen the
+                // wrong conversation under the durable Console sessionId. Fail closed
+                // before open when the persisted file is absent.
+                await access(opts.sessionFile);
+            }
+            catch (error) {
+                const code = error && typeof error === "object" && "code" in error
+                    ? String(error.code ?? "")
+                    : "";
+                if (code === "ENOENT") {
+                    throw Object.assign(new Error(`SESSION_FILE_MISSING: ${opts.sessionFile}`), { code: "SESSION_FILE_MISSING", cause: error });
+                }
+                // File exists but is unreadable (permissions / I/O) — caller maps
+                // undefined to 503 rather than silently creating a fresh session.
+                return undefined;
+            }
+            return sdk.SessionManager.open(opts.sessionFile);
+        },
+        resolveModel: (opts) => {
+            const rt = opts.modelRuntime;
+            if (typeof rt?.getModel !== "function")
+                return undefined;
+            try {
+                return rt.getModel(opts.provider, opts.modelId);
+            }
+            catch {
+                return undefined;
+            }
+        },
+        listAvailableModels: (opts) => {
+            const rt = opts.modelRuntime;
+            const available = rt?.snapshot?.available ?? [];
+            const configured = rt?.snapshot?.configuredProviders;
+            const isConfigured = (provider) => configured instanceof Set ? configured.has(provider) : false;
+            return available.map((m) => ({
+                id: m.id,
+                name: m.name,
+                provider: m.provider,
+                hasCredentials: isConfigured(m.provider),
+            }));
+        },
+    };
+}

package/dist/worker/console/chat/pi-runtime/sdk-session.js

@@ -0,0 +1,5 @@
+/**
+ * Pi SDK session contracts used by Console Chat. Kept below pi-runtime.ts so
+ * adapters and subagents can import types without a runtime cycle.
+ */
+export {};