@dungle-scrubs/tallow 0.9.4 → 0.9.7

package/dist/sdk.js

@@ -1,8 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, delimiter, dirname, join, resolve, sep } from "node:path";
-import { bashTool, codingTools, createAgentSession, createEventBus, DefaultPackageManager, DefaultResourceLoader, editTool, findTool, grepTool, lsTool, ModelRegistry, readOnlyTools, readTool, SessionManager, SettingsManager, writeTool, } from "@mariozechner/pi-coding-agent";
-import * as PiTui from "@mariozechner/pi-tui";
+import { createAgentSession, createAgentSessionRuntime, createEventBus, DefaultPackageManager, DefaultResourceLoader, ModelRegistry, SessionManager, SettingsManager, } from "@mariozechner/pi-coding-agent";
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { createSecureAuthStorage, resolveRuntimeApiKeyFromEnv } from "./auth-hardening.js";
 import { applyAgentSessionCompactionCancelPatch } from "./compaction-cancel-patch.js";
@@ -10,6 +9,7 @@ import { BUNDLED, bootstrap, getRuntimeTallowHome, resolveOpSecrets, TALLOW_VERS
 import { applyInteractiveModeStaleUiPatch } from "./interactive-mode-patch.js";
 import { applyKnownModelMetadataOverrides } from "./model-metadata-overrides.js";
 import { createTelemetryHandle, extractTraceContextFromEnv, sessionAttributes, TELEMETRY_API_CHANNELS, } from "./otel.js";
+import { applyPiTuiPatches } from "./pi-tui-patch.js";
 import { cleanupOrphanPids } from "./pid-manager.js";
 import { extractClaudePluginResources, readPluginManifest, resolvePlugins, } from "./plugins.js";
 import { applyProjectTrustContextToEnv, resolveProjectTrust, trustProject, untrustProject, } from "./project-trust.js";
@@ -48,32 +48,25 @@ const CONTEXT_BUDGET_API_CHANNELS = {
 };
 /** Default TTL for per-tool context-budget envelopes. */
 const CONTEXT_BUDGET_ENVELOPE_TTL_MS = 30_000;
-/** Map of tool name → tool object for --tools flag resolution. */
-const TOOL_MAP = {
-    read: readTool,
-    bash: bashTool,
-    edit: editTool,
-    write: writeTool,
-    grep: grepTool,
-    find: findTool,
-    ls: lsTool,
-};
-/** Preset aliases for --tools flag. */
+const INDIVIDUAL_TOOL_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
+const CODING_TOOL_NAMES = ["read", "bash", "edit", "write"];
+const READONLY_TOOL_NAMES = ["read", "grep", "find", "ls"];
+/** Map of tool preset alias → tool names for --tools flag resolution. */
 const TOOL_PRESETS = {
-    readonly: readOnlyTools,
-    coding: codingTools,
+    readonly: READONLY_TOOL_NAMES,
+    coding: CODING_TOOL_NAMES,
     none: [],
 };
 /** All valid tool names and aliases for error messages. */
-const VALID_TOOL_NAMES = [...Object.keys(TOOL_MAP), ...Object.keys(TOOL_PRESETS)];
+const VALID_TOOL_NAMES = [...INDIVIDUAL_TOOL_NAMES, ...Object.keys(TOOL_PRESETS)];
 /**
- * Parse a comma-separated tool names string into an array of tool objects.
+ * Parse a comma-separated tool names string into an array of tool names.
  *
  * Accepts individual tool names (read, bash, edit, write, grep, find, ls)
  * and preset aliases (readonly, coding, none).
  *
  * @param toolString - Comma-separated tool names (e.g. "read,grep,find")
- * @returns Array of resolved tool objects
+ * @returns Array of resolved tool names
  * @throws Error with list of valid names when an unknown tool is specified
  */
 export function parseToolFlag(toolString) {
@@ -88,14 +81,16 @@ export function parseToolFlag(toolString) {
     if (names.length === 1 && names[0] in TOOL_PRESETS) {
         return [...TOOL_PRESETS[names[0]]];
     }
-    const tools = [];
+    const tools = new Set();
     const unknown = [];
     for (const name of names) {
-        if (name in TOOL_MAP) {
-            tools.push(TOOL_MAP[name]);
+        if (INDIVIDUAL_TOOL_NAMES.includes(name)) {
+            tools.add(name);
         }
         else if (name in TOOL_PRESETS) {
-            tools.push(...TOOL_PRESETS[name]);
+            for (const toolName of TOOL_PRESETS[name]) {
+                tools.add(toolName);
+            }
         }
         else {
             unknown.push(name);
@@ -104,15 +99,26 @@ export function parseToolFlag(toolString) {
     if (unknown.length > 0) {
         throw new Error(`Unknown tool(s): ${unknown.join(", ")}. Valid names: ${VALID_TOOL_NAMES.join(", ")}`);
     }
-    return tools;
+    return [...tools].sort((a, b) => a.localeCompare(b));
+}
+/**
+ * Extract tool names from the session tool allowlist.
+ *
+ * @param tools - Tool names from session options
+ * @returns Sorted unique tool names
+ */
+function extractConfiguredToolNames(tools) {
+    if (!tools)
+        return [];
+    return [...new Set(tools)].sort((a, b) => a.localeCompare(b));
 }
 /**
- * Extract tool names from a tool-definition array.
+ * Extract tool names from custom tool definitions.
  *
  * @param tools - Tool definitions from session options
  * @returns Sorted unique tool names
  */
-function extractToolNames(tools) {
+function extractCustomToolNames(tools) {
     if (!tools)
         return [];
     const names = new Set();
@@ -137,8 +143,8 @@ function extractToolNames(tools) {
 function resolveExplicitToolRestrictionNames(options) {
     if (options.tools === undefined)
         return null;
-    const names = new Set(extractToolNames(options.tools));
-    for (const name of extractToolNames(options.customTools)) {
+    const names = new Set(extractConfiguredToolNames(options.tools));
+    for (const name of extractCustomToolNames(options.customTools)) {
         names.add(name);
     }
     return [...names].sort((a, b) => a.localeCompare(b));
@@ -967,14 +973,41 @@ function applyExtensionStartupPolicies(base, options) {
  * await session.prompt("Fix the failing tests");
  * ```
  */
+/**
+ * Apply tallow runtime setting overrides that must be consistent across initial
+ * startup and runtime-backed session recreation.
+ *
+ * @param settingsManager - Settings manager to mutate
+ * @param runtimeSettings - Optional runtime settings overrides from SDK/CLI
+ * @param trustStatus - Effective project trust status for the target cwd
+ * @returns Nothing
+ */
+function applySessionSettingsOverrides(settingsManager, runtimeSettings, trustStatus) {
+    const global = settingsManager.getGlobalSettings();
+    const project = settingsManager.getProjectSettings();
+    if (global.quietStartup === undefined && project.quietStartup === undefined) {
+        settingsManager.applyOverrides({ quietStartup: true });
+    }
+    if (runtimeSettings) {
+        settingsManager.applyOverrides(runtimeSettings);
+    }
+    if (trustStatus !== "trusted") {
+        const globalPackages = settingsManager.getGlobalSettings().packages;
+        settingsManager.applyOverrides({
+            packages: (Array.isArray(globalPackages) ? globalPackages : []),
+        });
+    }
+}
 export async function createTallowSession(options = {}) {
     const startupProfile = normalizeStartupProfile(options.startupProfile);
     const startupTiming = createStartupTimingLogger(startupProfile);
     const createSessionStartedAtMs = Date.now();
+    const callerCwd = process.cwd();
     // Ensure env is configured before any framework internals resolve paths
     bootstrap();
     ensureTallowHome(startupProfile);
     if (startupProfile === "interactive") {
+        await applyPiTuiPatches();
         await applyInteractiveModeStaleUiPatch();
     }
     await applyAgentSessionCompactionCancelPatch();
@@ -1015,26 +1048,7 @@ export async function createTallowSession(options = {}) {
     }
     // ── Settings ─────────────────────────────────────────────────────────────
     const settingsManager = SettingsManager.create(cwd, tallowHome);
-    // Default to quiet startup — the welcome-screen extension provides the branded
-    // header, so the built-in keybinding list and resource listing are redundant.
-    // Only apply when the user/project settings haven't explicitly set the value.
-    {
-        const global = settingsManager.getGlobalSettings();
-        const project = settingsManager.getProjectSettings();
-        if (global.quietStartup === undefined && project.quietStartup === undefined) {
-            settingsManager.applyOverrides({ quietStartup: true });
-        }
-    }
-    // Runtime overrides from options.settings come last so they win.
-    if (options.settings) {
-        settingsManager.applyOverrides(options.settings);
-    }
-    if (projectTrust.status !== "trusted") {
-        const globalPackages = settingsManager.getGlobalSettings().packages;
-        settingsManager.applyOverrides({
-            packages: (Array.isArray(globalPackages) ? globalPackages : []),
-        });
-    }
+    applySessionSettingsOverrides(settingsManager, options.settings, projectTrust.status);
     const toolResultRetentionPolicy = resolveToolResultRetentionPolicy({
         globalSettings: settingsManager.getGlobalSettings(),
         projectSettings: settingsManager.getProjectSettings(),
@@ -1143,9 +1157,6 @@ export async function createTallowSession(options = {}) {
     // ── Package AGENTS.md loading ────────────────────────────────────────────
     // Packages contribute extensions, skills, prompts, themes — but the framework
     // doesn't load AGENTS.md from packages. Use agentsFilesOverride to inject them.
-    const packageAgentsFiles = loadAgentsFilesFromPackages(settingsManager, cwd);
-    const projectExtensionsDir = resolve(cwd, ".tallow", "extensions");
-    const shouldBlockProjectExtensions = projectTrust.status !== "trusted";
     if (projectTrust.status !== "trusted") {
         console.error(projectTrust.status === "stale_fingerprint"
             ? "\x1b[33m⚠ Project trust is stale — repo-controlled execution surfaces are blocked until /trust-project\x1b[0m"
@@ -1153,72 +1164,137 @@ export async function createTallowSession(options = {}) {
     }
     const dedupedExtensionPaths = [...new Set(additionalExtensionPaths)];
     const disabledExtensionNames = new Set(options.disabledExtensions ?? []);
-    const shouldApplyExtensionStartupPolicies = shouldBlockProjectExtensions ||
-        startupProfile === "headless" ||
-        disabledExtensionNames.size > 0;
     const explicitToolRestrictionNames = resolveExplicitToolRestrictionNames(options);
-    const loader = new DefaultResourceLoader({
-        cwd,
-        agentDir: tallowHome,
-        settingsManager,
-        eventBus,
-        additionalExtensionPaths: dedupedExtensionPaths,
-        additionalSkillPaths,
-        additionalPromptTemplatePaths: additionalPromptPaths,
-        additionalThemePaths,
-        extensionFactories: [
-            createRebrandSystemPromptExtension(contextBudgetPolicy),
-            injectImageFilePaths,
-            createToolResultRetentionExtension(toolResultRetentionPolicy, contextBudgetPolicy),
-            createContextBudgetPlannerExtension(contextBudgetPolicy),
-            detectOutputTruncation,
-            createProjectTrustExtension(cwd, projectTrust),
-            createTelemetryExtension(telemetry, cwd),
-            ...(explicitToolRestrictionNames
-                ? [createExplicitToolRestrictionExtension(explicitToolRestrictionNames)]
-                : []),
-            ...(options.extensionFactories ?? []),
-        ],
-        noExtensions: extensionsOnly,
-        extensionsOverride: shouldApplyExtensionStartupPolicies
-            ? (base) => applyExtensionStartupPolicies(base, {
-                blockProjectExtensions: shouldBlockProjectExtensions,
-                disabledExtensionNames,
-                projectExtensionsDir,
-                startupProfile,
-            })
-            : undefined,
-        systemPromptOverride: options.systemPrompt ? () => options.systemPrompt : undefined,
-        appendSystemPromptOverride: options.appendSystemPrompt
-            ? (base) => {
-                const append = options.appendSystemPrompt;
-                return append ? [...base, append] : base;
-            }
-            : undefined,
-        agentsFilesOverride: packageAgentsFiles.length > 0
-            ? (base) => ({
-                agentsFiles: [...base.agentsFiles, ...packageAgentsFiles],
-            })
-            : undefined,
-        skillsOverride: (base) => {
-            const normalized = normalizeSkillNames(base);
-            const extra = options.additionalSkills;
-            return {
-                skills: extra ? [...normalized.skills, ...extra] : normalized.skills,
-                diagnostics: normalized.diagnostics,
-            };
-        },
-        promptsOverride: options.additionalPrompts
-            ? (base) => {
-                const extra = options.additionalPrompts;
+    /**
+     * Create a runtime-backed session for the given cwd/session target.
+     *
+     * @param runtimeCwd - Effective session cwd
+     * @param runtimeSessionManager - Session manager to attach
+     * @param sessionStartEvent - Optional lifecycle metadata for replacement flows
+     * @returns Created session, extension load result, and runtime services
+     */
+    const createRuntime = async ({ cwd: runtimeCwd, sessionManager: runtimeSessionManager, sessionStartEvent, }) => {
+        const runtimeProjectTrust = resolveProjectTrust(runtimeCwd);
+        applyProjectTrustContextToEnv(runtimeProjectTrust);
+        const runtimeSettingsManager = SettingsManager.create(runtimeCwd, tallowHome);
+        applySessionSettingsOverrides(runtimeSettingsManager, options.settings, runtimeProjectTrust.status);
+        const runtimePackageAgentsFiles = loadAgentsFilesFromPackages(runtimeSettingsManager, runtimeCwd);
+        const runtimeProjectExtensionsDir = resolve(runtimeCwd, ".tallow", "extensions");
+        const runtimeShouldBlockProjectExtensions = runtimeProjectTrust.status !== "trusted";
+        const runtimeShouldApplyExtensionStartupPolicies = runtimeShouldBlockProjectExtensions ||
+            startupProfile === "headless" ||
+            disabledExtensionNames.size > 0;
+        const runtimeLoader = new DefaultResourceLoader({
+            cwd: runtimeCwd,
+            agentDir: tallowHome,
+            settingsManager: runtimeSettingsManager,
+            eventBus,
+            additionalExtensionPaths: dedupedExtensionPaths,
+            additionalSkillPaths,
+            additionalPromptTemplatePaths: additionalPromptPaths,
+            additionalThemePaths,
+            extensionFactories: [
+                createRebrandSystemPromptExtension(contextBudgetPolicy),
+                createToolResultRetentionExtension(toolResultRetentionPolicy, contextBudgetPolicy),
+                createContextBudgetPlannerExtension(contextBudgetPolicy),
+                detectOutputTruncation,
+                createProjectTrustExtension(runtimeCwd, runtimeProjectTrust),
+                createTelemetryExtension(telemetry, runtimeCwd),
+                ...(explicitToolRestrictionNames
+                    ? [createExplicitToolRestrictionExtension(explicitToolRestrictionNames)]
+                    : []),
+                ...(options.extensionFactories ?? []),
+            ],
+            noExtensions: extensionsOnly,
+            extensionsOverride: runtimeShouldApplyExtensionStartupPolicies
+                ? (base) => applyExtensionStartupPolicies(base, {
+                    blockProjectExtensions: runtimeShouldBlockProjectExtensions,
+                    disabledExtensionNames,
+                    projectExtensionsDir: runtimeProjectExtensionsDir,
+                    startupProfile,
+                })
+                : undefined,
+            systemPromptOverride: options.systemPrompt ? () => options.systemPrompt : undefined,
+            appendSystemPromptOverride: options.appendSystemPrompt
+                ? (base) => {
+                    const append = options.appendSystemPrompt;
+                    return append ? [...base, append] : base;
+                }
+                : undefined,
+            agentsFilesOverride: runtimePackageAgentsFiles.length > 0
+                ? (base) => ({
+                    agentsFiles: [...base.agentsFiles, ...runtimePackageAgentsFiles],
+                })
+                : undefined,
+            skillsOverride: (base) => {
+                const normalized = normalizeSkillNames(base);
+                const extra = options.additionalSkills;
                 return {
-                    prompts: extra ? [...base.prompts, ...extra] : base.prompts,
-                    diagnostics: base.diagnostics,
+                    skills: extra ? [...normalized.skills, ...extra] : normalized.skills,
+                    diagnostics: normalized.diagnostics,
                 };
+            },
+            promptsOverride: options.additionalPrompts
+                ? (base) => {
+                    const extra = options.additionalPrompts;
+                    return {
+                        prompts: extra ? [...base.prompts, ...extra] : base.prompts,
+                        diagnostics: base.diagnostics,
+                    };
+                }
+                : undefined,
+        });
+        await runtimeLoader.reload();
+        applySessionSettingsOverrides(runtimeSettingsManager, options.settings, runtimeProjectTrust.status);
+        let resolvedModel = options.model;
+        if (!resolvedModel && options.provider) {
+            const modelId = options.modelId ?? runtimeSettingsManager.getDefaultModel();
+            if (modelId) {
+                resolvedModel = modelRegistry.find(options.provider, modelId) ?? undefined;
+                if (!resolvedModel) {
+                    throw new Error(`Model ${options.provider}/${modelId} not found`);
+                }
             }
-            : undefined,
-    });
-    await loader.reload();
+            else {
+                const available = modelRegistry.getAll().filter((m) => m.provider === options.provider);
+                if (available.length === 0) {
+                    throw new Error(`No models found for provider "${options.provider}"`);
+                }
+                resolvedModel = available[0];
+            }
+        }
+        const result = await createAgentSession({
+            cwd: runtimeCwd,
+            agentDir: tallowHome,
+            model: resolvedModel,
+            thinkingLevel: options.thinkingLevel,
+            authStorage,
+            modelRegistry,
+            resourceLoader: runtimeLoader,
+            sessionManager: runtimeSessionManager,
+            settingsManager: runtimeSettingsManager,
+            tools: options.tools,
+            customTools: options.customTools,
+            sessionStartEvent,
+        });
+        if (explicitToolRestrictionNames) {
+            const sessionWithToolControl = result.session;
+            sessionWithToolControl.setActiveToolsByName?.(explicitToolRestrictionNames);
+        }
+        return {
+            ...result,
+            diagnostics: [],
+            services: {
+                agentDir: tallowHome,
+                authStorage,
+                cwd: runtimeCwd,
+                diagnostics: [],
+                modelRegistry,
+                resourceLoader: runtimeLoader,
+                settingsManager: runtimeSettingsManager,
+            },
+        };
+    };
     // ── Session Manager ──────────────────────────────────────────────────────
     let sessionManager;
     const sessionOpt = options.session ?? { type: "new" };
@@ -1259,49 +1335,35 @@ export async function createTallowSession(options = {}) {
             break;
         }
     }
-    // ── Model resolution (string → Model object) ────────────────────────────
-    let resolvedModel = options.model;
-    if (!resolvedModel && options.provider) {
-        const modelId = options.modelId ?? settingsManager.getDefaultModel();
-        if (modelId) {
-            resolvedModel = modelRegistry.find(options.provider, modelId) ?? undefined;
-            if (!resolvedModel) {
-                throw new Error(`Model ${options.provider}/${modelId} not found`);
-            }
+    const initialSessionStartEvent = sessionOpt.type === "continue" || sessionOpt.type === "open" || sessionOpt.type === "resume"
+        ? {
+            type: "session_start",
+            reason: "resume",
+            previousSessionFile: sessionManager.getSessionFile(),
         }
-        else {
-            // Provider without model: find any available model for this provider
-            const available = modelRegistry.getAll().filter((m) => m.provider === options.provider);
-            if (available.length === 0) {
-                throw new Error(`No models found for provider "${options.provider}"`);
-            }
-            resolvedModel = available[0];
-        }
-    }
-    // ── Create Session ───────────────────────────────────────────────────────
-    const result = await createAgentSession({
+        : undefined;
+    const runtime = await createAgentSessionRuntime(({ cwd: runtimeCwd, sessionManager: runtimeSessionManager, sessionStartEvent }) => createRuntime({
+        cwd: runtimeCwd,
+        sessionManager: runtimeSessionManager,
+        sessionStartEvent,
+    }), {
         cwd,
         agentDir: tallowHome,
-        model: resolvedModel,
-        thinkingLevel: options.thinkingLevel,
-        authStorage,
-        modelRegistry,
-        resourceLoader: loader,
         sessionManager,
-        settingsManager,
-        tools: options.tools,
-        customTools: options.customTools,
+        sessionStartEvent: initialSessionStartEvent,
     });
-    if (explicitToolRestrictionNames) {
-        const sessionWithToolControl = result.session;
-        sessionWithToolControl.setActiveToolsByName?.(explicitToolRestrictionNames);
+    if (process.cwd() !== callerCwd) {
+        process.chdir(callerCwd);
     }
     startupTiming.mark("create-session", createSessionStartedAtMs);
-    instrumentSessionStartupTimings(result.session, startupTiming);
+    instrumentSessionStartupTimings(runtime.session, startupTiming);
     return {
-        session: result.session,
-        extensions: result.extensionsResult,
-        modelFallbackMessage: result.modelFallbackMessage,
+        runtime,
+        get session() {
+            return runtime.session;
+        },
+        extensions: runtime.services.resourceLoader.getExtensions(),
+        modelFallbackMessage: runtime.modelFallbackMessage,
         version: TALLOW_VERSION,
         extensionOverrides,
         resolvedPlugins,
@@ -1679,29 +1741,6 @@ function createRebrandSystemPromptExtension(budgetPolicy) {
         });
     };
 }
-/**
- * Injects file paths into Image components for clickable OSC 8 links.
- * When the read tool returns an image, sets the pending file path so
- * the next Image constructor picks it up automatically.
- *
- * @param pi - Extension API
- */
-function injectImageFilePaths(pi) {
-    pi.on("tool_result", async (event) => {
-        if (event.toolName !== "read")
-            return;
-        const hasImage = event.content?.some((c) => c.type === "image");
-        if (hasImage && event.input?.path) {
-            const filePath = resolve(String(event.input.path));
-            // pi-tui >= 0.55 may not expose this helper; skip injection when unavailable.
-            const maybeSetNextImageFilePath = PiTui
-                .setNextImageFilePath;
-            if (typeof maybeSetNextImageFilePath === "function") {
-                maybeSetNextImageFilePath(filePath);
-            }
-        }
-    });
-}
 /**
  * Create a built-in extension that summarizes oversized historical tool results.
  *
@@ -1897,7 +1936,7 @@ function truncateTextToBytes(text, maxBytes) {
  * message content and allocates a budget envelope for each one, keyed
  * by toolCallId. Envelopes are single-use (consumed via the API) and
  * automatically cleaned up on turn_end, agent_end, session_before_switch,
- * and session_switch events.
+ * and post-transition session_start events.
  *
  * @param budgetPolicy - Resolved context-budget policy
  * @returns Extension factory
@@ -2003,6 +2042,7 @@ function createContextBudgetPlannerExtension(budgetPolicy) {
             },
         };
         pi.on("session_start", async () => {
+            clearEnvelopes();
             publishBudgetApi();
         });
         pi.events.on(CONTEXT_BUDGET_API_CHANNELS.budgetApiRequest, () => {
@@ -2017,9 +2057,6 @@ function createContextBudgetPlannerExtension(budgetPolicy) {
         pi.on("session_before_switch", async () => {
             clearEnvelopes();
         });
-        pi.on("session_switch", async () => {
-            clearEnvelopes();
-        });
     };
 }
 /**