@lotagate/cli 0.1.22 → 0.1.23

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

@@ -1,74 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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>;