@lotagate/cli 0.1.20 → 0.1.22

package/dist/application/project/project-trust-service.js

@@ -0,0 +1,74 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { CliError } from '../../domain/errors/cli-error.js';
+import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
+import { createProjectFingerprint } from '../../domain/project/project-identity.js';
+import { TRUST_GRANT_HINT } from '../commands/command-hints.js';
+export class ProjectTrustService {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async inspect(inputPath) {
+        const canonicalPath = await this.canonicalize(inputPath);
+        const gitRoot = await findGitRoot(canonicalPath);
+        return {
+            canonicalPath,
+            ...(gitRoot !== undefined ? { gitRoot } : {}),
+            fingerprint: createProjectFingerprint(canonicalPath, gitRoot),
+        };
+    }
+    async isTrusted(identity) {
+        return (await this.store.get(identity.fingerprint)) !== undefined;
+    }
+    async grant(identity) {
+        const trusted = {
+            fingerprint: identity.fingerprint,
+            canonicalPath: identity.canonicalPath,
+            grantedAt: new Date().toISOString(),
+            grantedBy: 'user',
+        };
+        await this.store.grant(trusted);
+        return trusted;
+    }
+    async revoke(identity) {
+        return this.store.revoke(identity.fingerprint);
+    }
+    async requireTrusted(identity) {
+        if (!(await this.isTrusted(identity))) {
+            throw new CliError(CLI_ERROR_CODES.PROJECT_TRUST_REQUIRED, 'Project trust is required.', {
+                category: 'project',
+                userMessage: `Project is not trusted: ${identity.canonicalPath}.`, hint: TRUST_GRANT_HINT,
+            });
+        }
+    }
+    async list() {
+        return this.store.list();
+    }
+    async canonicalize(inputPath) {
+        const resolved = path.resolve(inputPath);
+        try {
+            return await fs.realpath(resolved);
+        }
+        catch (error) {
+            throw new CliError(CLI_ERROR_CODES.PROJECT_PATH_INVALID, `Project path does not exist: ${resolved}`, {
+                category: 'project', userMessage: `Project path was not found: ${resolved}.`, cause: error,
+            });
+        }
+    }
+}
+async function findGitRoot(start) {
+    let current = start;
+    while (true) {
+        try {
+            const stat = await fs.stat(path.join(current, '.git'));
+            if (stat.isDirectory() || stat.isFile())
+                return current;
+        }
+        catch { /* Continue walking towards the filesystem root. */ }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}

package/dist/application/protocol/browser-host-tool-executor.d.ts

@@ -0,0 +1,41 @@
+import type { ToolDefinition } from '@lotagate/sdk';
+import type { ToolExecutionContext, ToolExecutor, ToolInfo, ToolResult } from '@lotagate/agent-sdk';
+import type { ToolActivityObserver } from '../../ports/tool-activity.js';
+export interface BrowserHostRequest {
+    version: 2;
+    type: 'host.request';
+    requestId: string;
+    tool: 'browser';
+    sessionId: string;
+    runId: string;
+    action: string;
+    params: Record<string, unknown>;
+    executionBoundary: 'host';
+    hostFallback: 'deny';
+}
+export interface BrowserHostResponse {
+    version: 2;
+    type: 'host.response';
+    requestId: string;
+    tool: 'browser';
+    ok: boolean;
+    result?: unknown;
+    error?: {
+        code: string;
+        category: string;
+        message: string;
+        retryable: boolean;
+    };
+}
+export type BrowserHostInvoker = (request: BrowserHostRequest, signal?: AbortSignal) => Promise<BrowserHostResponse>;
+export declare function browserToolDefinitions(): readonly ToolDefinition[];
+export declare class BrowserHostToolExecutor implements ToolExecutor {
+    private readonly options;
+    constructor(options: {
+        request: BrowserHostInvoker;
+        onActivity?: ToolActivityObserver;
+    });
+    listTools(): readonly ToolDefinition[];
+    getToolInfo(toolName: string): ToolInfo | undefined;
+    execute(toolName: string, input: Record<string, unknown>, context: ToolExecutionContext): Promise<ToolResult>;
+}

package/dist/application/protocol/browser-host-tool-executor.js

@@ -0,0 +1,88 @@
+import { randomUUID } from 'node:crypto';
+const BROWSER_TOOLS = [
+    functionTool('browser.navigate', 'Open an HTTP(S) URL in the agent browser.', { url: stringProperty('Destination URL.'), tabId: stringProperty('Optional browser tab id.') }, ['url']),
+    functionTool('browser.newTab', 'Open a new blank tab in the agent browser.', {}, []),
+    functionTool('browser.closeTab', 'Close the active browser tab.', { tabId: stringProperty('Optional browser tab id.') }, []),
+    functionTool('browser.selectTab', 'Make a browser tab active.', { tabId: stringProperty('Browser tab id.') }, ['tabId']),
+    functionTool('browser.inspect', 'Inspect the current page DOM summary, text, headings, links, and visible interactive elements.', { tabId: stringProperty('Optional browser tab id.') }, []),
+    functionTool('browser.inspectElement', 'Inspect a page element including its DOM, attributes, bounds, and computed CSS.', { target: targetSchema(), tabId: stringProperty('Optional browser tab id.') }, ['target']),
+    functionTool('browser.console', 'Read recent browser console messages and page errors.', { tabId: stringProperty('Optional browser tab id.'), limit: numberProperty('Maximum number of entries to return.') }, []),
+    functionTool('browser.network', 'Read recent browser network requests, HTTP failures, and request errors.', { tabId: stringProperty('Optional browser tab id.'), limit: numberProperty('Maximum number of entries to return.') }, []),
+    functionTool('browser.accessibility', 'Inspect the page accessibility tree without exposing control values.', { tabId: stringProperty('Optional browser tab id.') }, []),
+    functionTool('browser.setViewport', 'Emulate a responsive browser viewport for the current tab.', { width: numberProperty('Viewport width in CSS pixels.'), height: numberProperty('Viewport height in CSS pixels.'), mobile: booleanProperty('Whether to emulate a mobile layout.'), deviceScaleFactor: numberProperty('Optional device scale factor.') }, ['width', 'height']),
+    functionTool('browser.resetViewport', 'Reset the browser tab to its normal viewport.', { tabId: stringProperty('Optional browser tab id.') }, []),
+    functionTool('browser.screenshot', 'Capture the current browser tab as evidence.', { tabId: stringProperty('Optional browser tab id.') }, []),
+    functionTool('browser.click', 'Click a visible page element using an accessibility target, text, CSS selector, or coordinates.', { target: targetSchema() }, ['target']),
+    functionTool('browser.focus', 'Focus a visible page field or control.', { target: targetSchema() }, ['target']),
+    functionTool('browser.clear', 'Clear a visible editable page field.', { target: targetSchema() }, ['target']),
+    functionTool('browser.hover', 'Move the browser pointer over a visible page element.', { target: targetSchema() }, ['target']),
+    functionTool('browser.check', 'Check or uncheck a checkbox or radio input.', { target: targetSchema(), checked: booleanProperty('Whether the control should be checked.') }, ['target', 'checked']),
+    functionTool('browser.select', 'Select an option in a native HTML select control.', { target: targetSchema(), value: stringProperty('Option value or visible label.') }, ['target', 'value']),
+    functionTool('browser.readField', 'Read a visible non-password form field value.', { target: targetSchema() }, ['target']),
+    functionTool('browser.type', 'Enter text into a visible page field.', { target: targetSchema(), value: stringProperty('Text to enter.') }, ['target', 'value']),
+    functionTool('browser.upload', 'Upload a workspace file through a visible file input.', { target: targetSchema(), path: stringProperty('Workspace-relative or absolute file path.') }, ['target', 'path']),
+    functionTool('browser.download', 'Download an HTTP(S) resource to the Desktop downloads folder.', { url: stringProperty('HTTP(S) resource URL.'), tabId: stringProperty('Optional browser tab id.') }, ['url']),
+    functionTool('browser.dialog', 'Read or respond to the active alert, confirm, or prompt dialog.', { action: enumProperty(['read', 'accept', 'dismiss'], 'Dialog operation.'), promptText: stringProperty('Optional text for a prompt dialog.'), tabId: stringProperty('Optional browser tab id.') }, ['action']),
+    functionTool('browser.press', 'Press a keyboard key in the current browser tab.', { key: stringProperty('Key name, for example Enter or Tab.'), modifiers: stringArrayProperty('Optional modifiers: Alt, Control, Shift, or Meta.'), tabId: stringProperty('Optional browser tab id.') }, ['key']),
+    functionTool('browser.scroll', 'Scroll the current browser tab.', { deltaX: numberProperty('Horizontal scroll amount.'), deltaY: numberProperty('Vertical scroll amount.'), tabId: stringProperty('Optional browser tab id.') }, []),
+    functionTool('browser.back', 'Navigate the current browser tab back.', { tabId: stringProperty('Optional browser tab id.') }, []),
+    functionTool('browser.forward', 'Navigate the current browser tab forward.', { tabId: stringProperty('Optional browser tab id.') }, []),
+    functionTool('browser.reload', 'Reload the current browser tab.', { tabId: stringProperty('Optional browser tab id.') }, []),
+    functionTool('browser.waitFor', 'Wait until a URL, text fragment, or CSS selector appears.', { condition: waitConditionSchema(), timeoutMs: numberProperty('Maximum wait time in milliseconds.') }, ['condition']),
+    functionTool('browser.tabs', 'List tabs in the agent browser session.', {}, []),
+];
+export function browserToolDefinitions() { return BROWSER_TOOLS; }
+export class BrowserHostToolExecutor {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    listTools() { return browserToolDefinitions(); }
+    getToolInfo(toolName) {
+        if (!BROWSER_TOOLS.some(definition => getToolName(definition) === toolName))
+            return undefined;
+        const readOnly = ['browser.inspect', 'browser.inspectElement', 'browser.console', 'browser.network', 'browser.accessibility', 'browser.setViewport', 'browser.resetViewport', 'browser.screenshot', 'browser.tabs', 'browser.scroll', 'browser.focus', 'browser.hover', 'browser.waitFor'].includes(toolName);
+        return { toolName, source: 'custom', executorId: 'desktop-browser-host', metadata: { risk: readOnly ? 'read' : 'unknown' } };
+    }
+    async execute(toolName, input, context) {
+        if (!BROWSER_TOOLS.some(definition => getToolName(definition) === toolName))
+            return { content: `Unknown browser tool: ${toolName}`, isError: true };
+        const activity = this.options.onActivity?.start({ key: `${context.runId}:${toolName}`, toolName, source: 'browser', label: formatBrowserActivity(toolName, input) });
+        try {
+            const response = await this.options.request({ version: 2, type: 'host.request', requestId: randomUUID(), tool: 'browser', sessionId: context.sessionId, runId: context.runId, action: toolName, params: input, executionBoundary: 'host', hostFallback: 'deny' }, context.signal);
+            if (!response.ok) {
+                const message = response.error?.message ?? 'Desktop rejected the browser action.';
+                activity?.complete(true);
+                return { content: message, isError: true, metadata: { code: response.error?.code ?? 'BROWSER_HOST_ERROR', retryable: response.error?.retryable ?? false } };
+            }
+            const content = boundJson(response.result, context.maxResultBytes);
+            activity?.complete(false);
+            return { content, isError: false, metadata: { browser: true } };
+        }
+        catch (error) {
+            activity?.complete(true);
+            return { content: error instanceof Error ? error.message : 'Browser host request failed.', isError: true };
+        }
+    }
+}
+function functionTool(name, description, properties, required) {
+    return { type: 'function', function: { name, description, parameters: { type: 'object', properties, required, additionalProperties: false } } };
+}
+function stringProperty(description) { return { type: 'string', description }; }
+function numberProperty(description) { return { type: 'number', description }; }
+function booleanProperty(description) { return { type: 'boolean', description }; }
+function enumProperty(values, description) { return { type: 'string', enum: [...values], description }; }
+function stringArrayProperty(description) { return { type: 'array', items: { type: 'string' }, description }; }
+function targetSchema() { return { type: 'object', properties: { type: { type: 'string', enum: ['accessibility', 'text', 'css', 'coordinates'] }, role: { type: 'string' }, name: { type: 'string' }, value: { type: 'string' }, selector: { type: 'string' }, x: { type: 'number' }, y: { type: 'number' } }, required: ['type'], additionalProperties: false }; }
+function waitConditionSchema() { return { type: 'object', properties: { type: { type: 'string', enum: ['selector', 'text', 'url'] }, value: { type: 'string' } }, required: ['type', 'value'], additionalProperties: false }; }
+function getToolName(definition) { return 'function' in definition ? definition.function.name : undefined; }
+function boundJson(value, maxBytes) { const content = JSON.stringify(value ?? null); return Buffer.byteLength(content, 'utf8') <= maxBytes ? content : `${content.slice(0, Math.max(0, maxBytes - 12))}\n[truncated]`; }
+function formatBrowserActivity(toolName, input) {
+    if (toolName === 'browser.navigate')
+        return `Open ${typeof input['url'] === 'string' ? input['url'] : 'URL'}`;
+    if (toolName === 'browser.type')
+        return 'Enter text in browser';
+    if (toolName === 'browser.click')
+        return 'Click page element';
+    return toolName.replace(/^browser\./u, 'Browser ');
+}

package/dist/application/protocol/desktop-agent-command.d.ts

@@ -0,0 +1,9 @@
+import type { Readable, Writable } from 'node:stream';
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+export declare const DESKTOP_PROTOCOL_VERSION: 2;
+/**
+ * Local JSONL bridge for the Desktop application. It is deliberately kept in
+ * the CLI application layer: Desktop reuses CLI policy and runtime, while the
+ * public SDK packages remain independent libraries.
+ */
+export declare function runDesktopAgentCommand(runtime: CliRuntime, cwd: string, input: Readable, output: Writable): Promise<number>;