lsd-pi 1.3.2 → 1.3.7

package/dist/cli.js

@@ -17,6 +17,7 @@ import { getProjectSessionsDir } from './project-sessions.js';
 import { markStartup, printStartupTimings } from './startup-timings.js';
 import { bootstrapRtk, GSD_RTK_DISABLED_ENV } from './rtk.js';
 import { loadEffectivePreferences } from './shared-preferences.js';
+import { createLsdSettingsManager } from './lsd-settings-manager.js';
 // ---------------------------------------------------------------------------
 // V8 compile cache — Node 22+ can cache compiled bytecode across runs,
 // eliminating repeated parse/compile overhead for unchanged modules.
@@ -270,7 +271,7 @@ const { resolveModelsJsonPath } = await import('./models-resolver.js');
 const modelsJsonPath = resolveModelsJsonPath();
 const modelRegistry = new ModelRegistry(authStorage, modelsJsonPath);
 markStartup('ModelRegistry');
-const settingsManager = SettingsManager.create(agentDir);
+const settingsManager = createLsdSettingsManager(process.cwd(), agentDir);
 markStartup('SettingsManager.create');
 if (cliFlags.noSandbox) {
     process.env.PI_NO_SANDBOX = '1';

package/dist/lsd-settings-manager.d.ts

@@ -0,0 +1,2 @@
+import { SettingsManager } from '@gsd/pi-coding-agent';
+export declare function createLsdSettingsManager(cwd?: string, agentDir?: string): SettingsManager;

package/dist/lsd-settings-manager.js

@@ -0,0 +1,5 @@
+import { SettingsManager } from '@gsd/pi-coding-agent';
+import { agentDir as defaultAgentDir } from './app-paths.js';
+export function createLsdSettingsManager(cwd = process.cwd(), agentDir = defaultAgentDir) {
+    return SettingsManager.create(cwd, agentDir);
+}

package/dist/resource-loader.js

@@ -127,6 +127,25 @@ function collectFileEntries(dir, root, out) {
         }
     }
 }
+function hasMissingResourceEntries(srcDir, destDir) {
+    if (!existsSync(srcDir))
+        return false;
+    if (!existsSync(destDir))
+        return true;
+    for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+        const srcPath = join(srcDir, entry.name);
+        const destPath = join(destDir, entry.name);
+        if (!existsSync(destPath))
+            return true;
+        if (entry.isDirectory() && hasMissingResourceEntries(srcPath, destPath))
+            return true;
+    }
+    return false;
+}
+function hasMissingManagedResources(agentDir) {
+    return hasMissingResourceEntries(bundledExtensionsDir, join(agentDir, 'extensions'))
+        || hasMissingResourceEntries(join(resourcesDir, 'agents'), join(agentDir, 'agents'));
+}
 export function getNewerManagedResourceVersion(agentDir, currentVersion) {
     const managedVersion = readManagedResourceVersion(agentDir);
     if (!managedVersion) {
@@ -192,8 +211,18 @@ function syncResourceDir(srcDir, destDir) {
         for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
             if (entry.isDirectory()) {
                 const target = join(destDir, entry.name);
-                if (existsSync(target))
-                    rmSync(target, { recursive: true, force: true });
+                if (existsSync(target)) {
+                    try {
+                        rmSync(target, { recursive: true, force: true });
+                    }
+                    catch {
+                        // Retry once — macOS can create .DS_Store mid-deletion causing ENOTEMPTY
+                        try {
+                            rmSync(target, { recursive: true, force: true });
+                        }
+                        catch { /* non-fatal */ }
+                    }
+                }
             }
         }
         try {
@@ -386,7 +415,8 @@ export function initResources(agentDir) {
         // Version matches — check content fingerprint for same-version staleness.
         const currentHash = computeResourceFingerprint();
         const hasStaleExtensionFiles = hasStaleCompiledExtensionSiblings(join(agentDir, 'extensions'));
-        if (manifest.contentHash && manifest.contentHash === currentHash && !hasStaleExtensionFiles) {
+        const hasMissingResources = hasMissingManagedResources(agentDir);
+        if (manifest.contentHash && manifest.contentHash === currentHash && !hasStaleExtensionFiles && !hasMissingResources) {
             return;
         }
     }

package/dist/resources/extensions/browser-tools/tools/codegen.js

@@ -62,9 +62,10 @@ export function registerCodegenTools(pi, deps) {
                             }
                             break;
                         }
-                        case "browser_click_ref": {
+                        case "browser_ref": {
                             // Refs are session-specific — add comment
-                            testLines.push(`    // browser_click_ref: ${entry.paramsSummary} — replace with stable selector`);
+                            const refAction = params.action ?? "click";
+                            testLines.push(`    // browser_ref (${refAction}): ${entry.paramsSummary} — replace with stable selector`);
                             actionCount++;
                             break;
                         }
@@ -77,9 +78,8 @@ export function registerCodegenTools(pi, deps) {
                             }
                             break;
                         }
-                        case "browser_fill_ref": {
-                            testLines.push(`    // browser_fill_ref: ${entry.paramsSummary} — replace with stable selector`);
-                            actionCount++;
+                        case "browser_fill_ref_handled": {
+                            // Already handled by browser_ref above
                             break;
                         }
                         case "browser_key_press": {

package/dist/resources/extensions/browser-tools/tools/navigation.js

@@ -8,201 +8,130 @@ export function registerNavigationTools(pi, deps) {
     pi.registerTool({
         name: "browser_navigate",
         label: "Browser Navigate",
-        description: "Open the browser (if not already open) and navigate to a URL. Waits for network idle. Returns page title and current URL. Use ONLY for visually verifying locally-running web apps (e.g. http://localhost:3000). Do NOT use for documentation sites, GitHub, search results, or any external URL — use web_search instead. Screenshots are only captured when the `screenshot` parameter is set to true.",
+        description: "Navigate to a URL, go back/forward in history, or reload the page. " +
+            "Use ONLY for locally-running web apps (e.g. http://localhost:3000). " +
+            "Do NOT use for documentation sites, GitHub, or external URLs — use web_search instead.",
         parameters: Type.Object({
-            url: Type.String({ description: "URL to navigate to, e.g. http://localhost:3000" }),
+            action: Type.Union([
+                Type.Literal("goto"),
+                Type.Literal("go_back"),
+                Type.Literal("go_forward"),
+                Type.Literal("reload"),
+            ], { description: "'goto' — navigate to url (default), 'go_back'/'go_forward' — history, 'reload' — refresh page" }),
+            url: Type.Optional(Type.String({ description: "URL to navigate to (required for goto action)." })),
             screenshot: Type.Optional(Type.Boolean({ description: "Capture and return a screenshot (default: false)", default: false })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            let actionId = null;
-            let beforeState = null;
+            const action = params.action ?? "goto";
             try {
-                const { page: p } = await deps.ensureBrowser();
-                beforeState = await deps.captureCompactPageState(p, { includeBodyText: true });
-                actionId = deps.beginTrackedAction("browser_navigate", params, beforeState.url).id;
-                await p.goto(params.url, { waitUntil: "domcontentloaded", timeout: 30000 });
-                await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
-                await new Promise(resolve => setTimeout(resolve, 300));
-                const title = await p.title();
-                const url = p.url();
-                const viewport = p.viewportSize();
-                const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
-                const afterState = await deps.captureCompactPageState(p, { includeBodyText: true });
-                const summary = deps.formatCompactStateSummary(afterState);
-                const jsErrors = deps.getRecentErrors(p.url());
-                const diff = diffCompactStates(beforeState, afterState);
-                setLastActionBeforeState(beforeState);
-                setLastActionAfterState(afterState);
-                deps.finishTrackedAction(actionId, {
-                    status: "success",
-                    afterUrl: afterState.url,
-                    warningSummary: jsErrors.trim() || undefined,
-                    diffSummary: diff.summary,
-                    changed: diff.changed,
-                    beforeState,
-                    afterState,
-                });
-                let screenshotContent = [];
-                if (params.screenshot) {
-                    try {
-                        let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
-                        buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
-                        screenshotContent = [{ type: "image", data: buf.toString("base64"), mimeType: "image/jpeg" }];
-                    }
-                    catch { /* non-fatal — screenshot is optional, navigation result is still valid */ }
+                if (action === "goto") {
+                    return await gotoAction(params);
                 }
-                return {
-                    content: [
-                        { type: "text", text: `Navigated to: ${url}\nTitle: ${title}\nViewport: ${vpText}\nAction: ${actionId}${jsErrors}\n\nDiff:\n${deps.formatDiffText(diff)}\n\nPage summary:\n${summary}` },
-                        ...screenshotContent,
-                    ],
-                    details: { title, url, status: "loaded", viewport: vpText, actionId, diff },
-                };
-            }
-            catch (err) {
-                if (actionId !== null) {
-                    deps.finishTrackedAction(actionId, { status: "error", afterUrl: deps.getActivePageOrNull()?.url() ?? "", error: err.message, beforeState: beforeState ?? undefined });
+                else if (action === "go_back") {
+                    return await goBackForward("back");
                 }
-                const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-                const content = [{ type: "text", text: `Navigation failed: ${err.message}` }];
-                if (errorShot) {
-                    content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
+                else if (action === "go_forward") {
+                    return await goBackForward("forward");
                 }
-                return {
-                    content,
-                    details: { status: "error", error: err.message, actionId },
-                    isError: true,
-                };
-            }
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_go_back
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_go_back",
-        label: "Browser Go Back",
-        description: "Navigate back in browser history. Returns a compact page summary after navigation.",
-        parameters: Type.Object({}),
-        async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
-            try {
-                const { page: p } = await deps.ensureBrowser();
-                const response = await p.goBack({ waitUntil: "domcontentloaded", timeout: 10000 });
-                if (!response) {
-                    return {
-                        content: [{ type: "text", text: "No previous page in history." }],
-                        details: {},
-                        isError: true,
-                    };
-                }
-                await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
-                const title = await p.title();
-                const url = p.url();
-                const summary = await deps.postActionSummary(p);
-                const jsErrors = deps.getRecentErrors(p.url());
-                return {
-                    content: [{ type: "text", text: `Navigated back to: ${url}\nTitle: ${title}${jsErrors}\n\nPage summary:\n${summary}` }],
-                    details: { title, url },
-                };
-            }
-            catch (err) {
-                const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-                const content = [{ type: "text", text: `Go back failed: ${err.message}` }];
-                if (errorShot) {
-                    content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
-                }
-                return { content, details: { error: err.message }, isError: true };
-            }
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_go_forward
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_go_forward",
-        label: "Browser Go Forward",
-        description: "Navigate forward in browser history. Returns a compact page summary after navigation.",
-        parameters: Type.Object({}),
-        async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
-            try {
-                const { page: p } = await deps.ensureBrowser();
-                const response = await p.goForward({ waitUntil: "domcontentloaded", timeout: 10000 });
-                if (!response) {
-                    return {
-                        content: [{ type: "text", text: "No forward page in history." }],
-                        details: {},
-                        isError: true,
-                    };
+                else {
+                    return await reloadAction();
                 }
-                await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
-                const title = await p.title();
-                const url = p.url();
-                const summary = await deps.postActionSummary(p);
-                const jsErrors = deps.getRecentErrors(p.url());
-                return {
-                    content: [{ type: "text", text: `Navigated forward to: ${url}\nTitle: ${title}${jsErrors}\n\nPage summary:\n${summary}` }],
-                    details: { title, url },
-                };
             }
             catch (err) {
                 const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-                const content = [{ type: "text", text: `Go forward failed: ${err.message}` }];
-                if (errorShot) {
+                const content = [{ type: "text", text: `Navigation '${action}' failed: ${err.message}` }];
+                if (errorShot)
                     content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
-                }
                 return { content, details: { error: err.message }, isError: true };
             }
         },
     });
-    // -------------------------------------------------------------------------
-    // browser_reload
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_reload",
-        label: "Browser Reload",
-        description: "Reload the current page. Returns a screenshot, compact page summary, and page metadata (same shape as browser_navigate).",
-        parameters: Type.Object({}),
-        async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+    // ── action implementations ──
+    async function gotoAction(params) {
+        if (!params.url) {
+            return { content: [{ type: "text", text: "Goto requires a 'url' parameter." }], details: { error: "missing_url" }, isError: true };
+        }
+        let actionId = null;
+        let beforeState = null;
+        const { page: p } = await deps.ensureBrowser();
+        beforeState = await deps.captureCompactPageState(p, { includeBodyText: true });
+        actionId = deps.beginTrackedAction("browser_navigate", params, beforeState.url).id;
+        await p.goto(params.url, { waitUntil: "domcontentloaded", timeout: 30000 });
+        await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
+        await new Promise(resolve => setTimeout(resolve, 300));
+        const title = await p.title();
+        const url = p.url();
+        const viewport = p.viewportSize();
+        const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
+        const afterState = await deps.captureCompactPageState(p, { includeBodyText: true });
+        const summary = deps.formatCompactStateSummary(afterState);
+        const jsErrors = deps.getRecentErrors(p.url());
+        const diff = diffCompactStates(beforeState, afterState);
+        setLastActionBeforeState(beforeState);
+        setLastActionAfterState(afterState);
+        deps.finishTrackedAction(actionId, {
+            status: "success", afterUrl: afterState.url, warningSummary: jsErrors.trim() || undefined,
+            diffSummary: diff.summary, changed: diff.changed, beforeState, afterState,
+        });
+        let screenshotContent = [];
+        if (params.screenshot) {
             try {
-                const { page: p } = await deps.ensureBrowser();
-                await p.reload({ waitUntil: "domcontentloaded", timeout: 30000 });
-                await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
-                const title = await p.title();
-                const url = p.url();
-                const viewport = p.viewportSize();
-                const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
-                const summary = await deps.postActionSummary(p);
-                const jsErrors = deps.getRecentErrors(p.url());
-                let screenshotContent = [];
-                try {
-                    let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
-                    buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
-                    screenshotContent = [{
-                            type: "image",
-                            data: buf.toString("base64"),
-                            mimeType: "image/jpeg",
-                        }];
-                }
-                catch { /* non-fatal — screenshot is optional, reload result is still valid */ }
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Reloaded: ${url}\nTitle: ${title}\nViewport: ${vpText}${jsErrors}\n\nPage summary:\n${summary}`,
-                        },
-                        ...screenshotContent,
-                    ],
-                    details: { title, url, viewport: vpText },
-                };
+                let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
+                buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
+                screenshotContent = [{ type: "image", data: buf.toString("base64"), mimeType: "image/jpeg" }];
             }
-            catch (err) {
-                const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-                const content = [{ type: "text", text: `Reload failed: ${err.message}` }];
-                if (errorShot) {
-                    content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
-                }
-                return { content, details: { error: err.message }, isError: true };
-            }
-        },
-    });
+            catch { /* non-fatal */ }
+        }
+        return {
+            content: [
+                { type: "text", text: `Navigated to: ${url}\nTitle: ${title}\nViewport: ${vpText}\nAction: ${actionId}${jsErrors}\n\nDiff:\n${deps.formatDiffText(diff)}\n\nPage summary:\n${summary}` },
+                ...screenshotContent,
+            ],
+            details: { title, url, status: "loaded", viewport: vpText, actionId, diff },
+        };
+    }
+    async function goBackForward(direction) {
+        const { page: p } = await deps.ensureBrowser();
+        const response = direction === "back"
+            ? await p.goBack({ waitUntil: "domcontentloaded", timeout: 10000 })
+            : await p.goForward({ waitUntil: "domcontentloaded", timeout: 10000 });
+        if (!response) {
+            return {
+                content: [{ type: "text", text: `No ${direction} page in history.` }],
+                details: {},
+                isError: true,
+            };
+        }
+        await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
+        const title = await p.title();
+        const url = p.url();
+        const summary = await deps.postActionSummary(p);
+        const jsErrors = deps.getRecentErrors(p.url());
+        return {
+            content: [{ type: "text", text: `Navigated ${direction} to: ${url}\nTitle: ${title}${jsErrors}\n\nPage summary:\n${summary}` }],
+            details: { title, url },
+        };
+    }
+    async function reloadAction() {
+        const { page: p } = await deps.ensureBrowser();
+        await p.reload({ waitUntil: "domcontentloaded", timeout: 30000 });
+        await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
+        const title = await p.title();
+        const url = p.url();
+        const viewport = p.viewportSize();
+        const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
+        const summary = await deps.postActionSummary(p);
+        const jsErrors = deps.getRecentErrors(p.url());
+        let screenshotContent = [];
+        try {
+            let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
+            buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
+            screenshotContent = [{ type: "image", data: buf.toString("base64"), mimeType: "image/jpeg" }];
+        }
+        catch { /* non-fatal */ }
+        return {
+            content: [{ type: "text", text: `Reloaded: ${url}\nTitle: ${title}\nViewport: ${vpText}${jsErrors}\n\nPage summary:\n${summary}` }, ...screenshotContent],
+            details: { title, url, viewport: vpText },
+        };
+    }
 }