@lasso-ai/cli 1.5.0 → 2.0.0

package/dist/runtime/adapters/local-agent-adapter.js

@@ -0,0 +1,408 @@
+"use strict";
+/**
+ * LocalAgentAdapter - Shared base for external coding agent backends.
+ *
+ * Claude Code, OpenCode, Codex CLI, and Cursor are full coding agents with
+ * their own internal loops. Lasso does NOT wrap them in a competing model
+ * loop: it delegates a task, streams their native structured output,
+ * normalizes it into BackendEvents, and lets the orchestrator own
+ * diff review, verification, and session state.
+ *
+ * Every adapter in this package:
+ *   - invokes the agent's official non-interactive CLI with structured output
+ *     (JSON/JSONL), never human-readable terminal scraping,
+ *   - checks installation and authentication separately from execution,
+ *   - relies on WorkspaceGuard (owned by the orchestrator) for rollback, so
+ *     no agent's changes ever persist before user approval.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalAgentAdapter = exports.EventSink = void 0;
+exports.newRunState = newRunState;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_path_1 = __importDefault(require("node:path"));
+const execFileAsync = (0, node_util_1.promisify)(require("node:child_process").execFile);
+function newRunState() {
+    return {
+        errors: [],
+        conversation: [],
+        tools: [],
+        receivedTerminalSuccess: false,
+        cancelled: false,
+    };
+}
+/** Sink used by adapters while parsing native events → normalized BackendEvents */
+class EventSink {
+    taskId;
+    emitRaw;
+    state;
+    constructor(taskId, emitRaw, state) {
+        this.taskId = taskId;
+        this.emitRaw = emitRaw;
+        this.state = state;
+    }
+    emit(type, data) {
+        this.emitRaw({ type, taskId: this.taskId, timestamp: Date.now(), data });
+    }
+    progress(message) {
+        this.emit("task_progress", { message });
+    }
+    toolStarted(name, detail) {
+        this.emit("tool_started", { tool: name, detail });
+    }
+    toolCompleted(name, success = true, detail) {
+        this.emit("tool_completed", { tool: name, success, detail });
+        this.state.tools.push({ name, success, detail });
+    }
+    fileChange(operation, filePath) {
+        if (operation === "deleted")
+            this.emit("file_deleted", { filePath });
+        else if (operation === "created")
+            this.emit("file_created", { filePath });
+        else
+            this.emit("file_modified", { filePath });
+    }
+    error(message, options = {}) {
+        const agentError = {
+            id: node_crypto_1.default.randomUUID(),
+            type: options.authFailure ? "permission" : "execution",
+            message,
+            phase: "execute",
+            timestamp: Date.now(),
+            recoverable: options.recoverable ?? true,
+        };
+        this.state.errors.push(agentError);
+        if (options.authFailure)
+            this.state.authFailure = true;
+        if (options.asEvent !== false) {
+            this.emit("error", { error: agentError, message });
+        }
+    }
+}
+exports.EventSink = EventSink;
+class LocalAgentAdapter {
+    id;
+    type = "local_agent";
+    modelId;
+    config;
+    process;
+    currentTaskId;
+    killTimer;
+    constructor(config) {
+        this.id = `${this.constructor.name}-${node_crypto_1.default.randomUUID()}`;
+        this.config = config;
+        this.modelId = config.modelId || "";
+    }
+    /**
+     * Optional: extra stderr/stdout text inspection for failures
+     * (e.g. "Authentication required" messages).
+     */
+    inspectFailureText(text) {
+        return null;
+    }
+    /** Whether this adapter can resume its own external session */
+    get supportsResume() {
+        return false;
+    }
+    // ── availability ─────────────────────────────────────────────────────
+    async checkAvailability() {
+        let version;
+        try {
+            const { stdout } = (await execFileAsync(this.binary, this.versionArgs, {
+                timeout: 8000,
+                windowsHide: true,
+            }));
+            version = stdout.trim().split("\n")[0]?.trim() || undefined;
+        }
+        catch {
+            return {
+                available: false,
+                installed: false,
+                authenticated: false,
+                error: `${this.provider} is not installed (${this.binary} not found on PATH).`,
+                fixInstructions: this.installInstructions,
+            };
+        }
+        const auth = await this.checkAuthentication();
+        if (!auth.authenticated) {
+            return {
+                available: false,
+                installed: true,
+                authenticated: false,
+                version,
+                error: auth.error || `${this.provider} is installed but not authenticated.`,
+                fixInstructions: auth.fixInstructions || this.installInstructions,
+            };
+        }
+        return { available: true, installed: true, authenticated: true, version };
+    }
+    // ── execution ────────────────────────────────────────────────────────
+    async executeTask(context, onEvent, signal) {
+        this.currentTaskId = context.taskId;
+        const state = newRunState();
+        const sink = new EventSink(context.taskId, onEvent, state);
+        sink.emit("task_started", { provider: this.provider, model: this.modelId || undefined });
+        sink.state.conversation.push({ role: "user", content: context.userPrompt, timestamp: Date.now() });
+        if (signal?.aborted) {
+            state.cancelled = true;
+            return this.buildResult(state, context, -1);
+        }
+        let command;
+        try {
+            command = this.buildCommand(context);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to build agent command";
+            sink.error(message, { recoverable: false });
+            sink.emit("task_failed", { error: message });
+            return this.buildResult(state, context, -1);
+        }
+        const spawnEnv = { ...process.env, ...(command.env || {}) };
+        return new Promise((resolve) => {
+            let stdoutBuffer = "";
+            let stderrBuffer = "";
+            let settled = false;
+            const child = (0, node_child_process_1.spawn)(command.bin, command.args, {
+                cwd: command.cwd,
+                env: spawnEnv,
+                stdio: ["ignore", "pipe", "pipe"],
+                // Agents inherit PATH-resolved binaries; do not open a shell.
+            });
+            this.process = child;
+            const onAbort = () => {
+                void this.cancelTask(context.taskId);
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            const processLine = (line) => {
+                if (!line.trim())
+                    return;
+                try {
+                    this.handleLine(line, context, sink);
+                }
+                catch {
+                    // A single malformed event must not kill the run; record it.
+                    sink.state.errors.push({
+                        id: node_crypto_1.default.randomUUID(),
+                        type: "unknown",
+                        message: `Skipped unparseable agent event: ${line.slice(0, 300)}`,
+                        phase: "execute",
+                        timestamp: Date.now(),
+                        recoverable: true,
+                    });
+                }
+            };
+            child.stdout?.on("data", (chunk) => {
+                stdoutBuffer += chunk.toString("utf8");
+                const lines = stdoutBuffer.split("\n");
+                stdoutBuffer = lines.pop() || "";
+                for (const line of lines)
+                    processLine(line);
+            });
+            child.stderr?.on("data", (chunk) => {
+                stderrBuffer = (stderrBuffer + chunk.toString("utf8")).slice(-16000);
+            });
+            const finish = (exitCode) => {
+                if (settled)
+                    return;
+                settled = true;
+                signal?.removeEventListener("abort", onAbort);
+                if (this.killTimer)
+                    clearTimeout(this.killTimer);
+                this.process = undefined;
+                if (stdoutBuffer.trim())
+                    processLine(stdoutBuffer);
+                // Determine outcome. Success requires BOTH a clean exit and the
+                // agent's own terminal success signal (when the format provides one).
+                const failureText = [state.failureMessage, stderrBuffer.trim()].filter(Boolean).join("\n");
+                const inspected = !state.failureMessage ? this.inspectFailureText(failureText) : null;
+                if (inspected && !state.errors.some((e) => e.message === inspected.message)) {
+                    sink.error(inspected.message, { recoverable: false, authFailure: inspected.authFailure });
+                }
+                if (state.cancelled || signal?.aborted) {
+                    state.cancelled = true;
+                    sink.emit("task_cancelled", {});
+                }
+                else if (state.receivedTerminalSuccess && exitCode === 0 && !state.failureMessage) {
+                    sink.emit("task_completed", { summary: state.summary });
+                }
+                else {
+                    const message = state.failureMessage ||
+                        inspected?.message ||
+                        (exitCode === 0
+                            ? `${this.provider} finished without reporting a successful result.`
+                            : `${this.provider} exited with code ${exitCode}${stderrBuffer ? `: ${stderrBuffer.trim().slice(-500)}` : ""}`);
+                    if (!state.errors.some((e) => e.message === message)) {
+                        sink.error(message, { recoverable: false, authFailure: state.authFailure });
+                    }
+                    sink.emit("task_failed", { error: message, exitCode });
+                }
+                resolve(this.buildResult(state, context, exitCode));
+            };
+            child.on("close", (code) => finish(code ?? -1));
+            child.on("error", (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                signal?.removeEventListener("abort", onAbort);
+                this.process = undefined;
+                sink.error(error.message, { recoverable: false });
+                sink.emit("task_failed", { error: error.message });
+                resolve(this.buildResult(state, context, -1));
+            });
+        });
+    }
+    async cancelTask(taskId) {
+        if (!this.process || this.currentTaskId !== taskId)
+            return;
+        const child = this.process;
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            // Already exited.
+        }
+        this.killTimer = setTimeout(() => {
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+                // Already exited.
+            }
+        }, 3000);
+        this.killTimer.unref?.();
+    }
+    async switchBackend(newBackend, context) {
+        const lostContext = this.supportsResume
+            ? [
+                `${this.provider} maintains its own internal session state that cannot be transferred to ${newBackend.provider}.`,
+                "Tool call history and per-file context held by the previous agent are not portable.",
+            ]
+            : [
+                `${this.provider} does not expose resumable session state for transfer.`,
+                "Tool call history and per-file context held by the previous agent are not portable.",
+            ];
+        return {
+            transferableContext: {
+                conversation: context.conversation,
+                observations: context.previousObservations,
+                errors: context.previousErrors,
+                userPrompt: context.userPrompt,
+                project: context.project,
+                externalSessionId: context.sessionRef?.id,
+            },
+            lostContext,
+        };
+    }
+    // ── helpers for subclasses ───────────────────────────────────────────
+    /** Build the shared task prompt (project context + continuation context). */
+    buildTaskPrompt(context) {
+        const lines = [];
+        lines.push("You are working inside a Lasso-managed review workflow.");
+        lines.push("Complete the following task by editing this project directly:");
+        lines.push("");
+        lines.push(context.userPrompt);
+        lines.push("");
+        lines.push("Project context:");
+        lines.push(`- Path: ${this.config.projectPath}`);
+        lines.push(`- Framework: ${context.project.framework || "unknown"}`);
+        lines.push(`- TypeScript: ${context.project.hasTypeScript ? "yes" : "no"}`);
+        lines.push(`- React: ${context.project.hasReact ? "yes" : "no"}`);
+        if (context.selection) {
+            lines.push("");
+            lines.push("Selected element:");
+            if (context.selection.element) {
+                lines.push(`- Tag: ${context.selection.element.tag}`);
+                if (context.selection.element.text)
+                    lines.push(`- Text: ${context.selection.element.text}`);
+            }
+            if (context.selection.route)
+                lines.push(`- Route: ${context.selection.route}`);
+        }
+        if (context.conversation.length > 1) {
+            lines.push("");
+            lines.push("Conversation so far:");
+            for (const msg of context.conversation.slice(-6)) {
+                lines.push(`${msg.role}: ${msg.content}`);
+            }
+        }
+        if (context.previousObservations.length > 0) {
+            lines.push("");
+            lines.push("Previous observations:");
+            for (const obs of context.previousObservations.slice(-5)) {
+                lines.push(`- ${obs.type}: ${obs.summary}`);
+            }
+        }
+        if (context.previousErrors.length > 0) {
+            lines.push("");
+            lines.push("Errors from previous attempts (fix these):");
+            for (const err of context.previousErrors.slice(-5)) {
+                lines.push(`- [${err.type}] ${err.message}`);
+            }
+        }
+        lines.push("");
+        lines.push("Notes:");
+        lines.push("- Your file changes will be captured as a diff, reviewed by the user, and only applied if approved.");
+        lines.push("- Do not commit, push, or perform operations outside this project directory.");
+        return lines.join("\n");
+    }
+    /** Resume reference from Lasso's canonical session state (if any). */
+    resumeSessionId(context) {
+        return context.sessionRef?.id;
+    }
+    /** Convert an absolute path reported by the agent to a project-relative one. */
+    relPath(absoluteOrRelative) {
+        if (!node_path_1.default.isAbsolute(absoluteOrRelative))
+            return absoluteOrRelative;
+        const rel = node_path_1.default.relative(this.config.projectPath, absoluteOrRelative);
+        if (!rel || rel.startsWith(".."))
+            return absoluteOrRelative;
+        return rel;
+    }
+    buildResult(state, context, exitCode) {
+        const cancelled = state.cancelled;
+        const success = !cancelled && state.receivedTerminalSuccess && exitCode === 0 && !state.failureMessage;
+        const observations = [
+            {
+                id: node_crypto_1.default.randomUUID(),
+                type: "tool",
+                summary: `${this.provider} ${cancelled ? "was cancelled" : success ? "completed the task" : "failed the task"} (${state.tools.length} tool call${state.tools.length === 1 ? "" : "s"})`,
+                data: {
+                    provider: this.provider,
+                    model: this.modelId || undefined,
+                    tools: state.tools,
+                    exitCode,
+                },
+                timestamp: Date.now(),
+                phase: "execute",
+            },
+        ];
+        if (state.summary) {
+            state.conversation.push({ role: "assistant", content: state.summary, timestamp: Date.now() });
+        }
+        return {
+            success,
+            status: cancelled ? "cancelled" : success ? "completed" : "failed",
+            summary: state.summary || (cancelled ? "Task cancelled" : success ? `${this.provider} completed the task` : state.failureMessage || `${this.provider} failed`),
+            // File changes are authoritative from WorkspaceGuard (orchestrator-side diff),
+            // not from the agent's own claims.
+            fileChanges: [],
+            actions: [],
+            observations,
+            errors: state.errors,
+            conversation: state.conversation,
+            metadata: {
+                provider: this.provider,
+                model: this.modelId || undefined,
+                exitCode,
+                externalSessionId: state.sessionId,
+                resumable: Boolean(state.sessionId) && this.supportsResume,
+                tools: state.tools,
+            },
+        };
+    }
+}
+exports.LocalAgentAdapter = LocalAgentAdapter;

package/dist/runtime/adapters/opencode-adapter.d.ts

@@ -0,0 +1,43 @@
+/**
+ * OpenCode Adapter
+ *
+ * Adapter for the OpenCode CLI (`opencode run`), an open-source local coding agent.
+ *
+ * Invocation: opencode run --format json -m <provider/model> [--session <ses_...>] <message>
+ * with cwd set to the project path. Output is a raw JSON event stream
+ * (step_start / tool_use / text / step_finish) normalized into BackendEvents.
+ *
+ * File changes are not trusted from the agent's report — the orchestrator's
+ * WorkspaceGuard diffs the project after the run and restores it before review.
+ *
+ * Reference: https://opencode.ai/docs/cli
+ */
+import { LocalAgentAdapter, LocalAgentConfig, CommandSpec, EventSink } from "./local-agent-adapter";
+import { BackendCapabilities, TaskContext } from "../backend-interface";
+interface OpenCodeConfig extends LocalAgentConfig {
+    provider: "opencode";
+}
+export declare class OpenCodeAdapter extends LocalAgentAdapter {
+    readonly provider: "opencode";
+    constructor(config: OpenCodeConfig);
+    getCapabilities(): BackendCapabilities;
+    protected get binary(): string;
+    protected get installInstructions(): string;
+    protected get versionArgs(): string[];
+    protected get supportsResume(): boolean;
+    protected checkAuthentication(): Promise<{
+        authenticated: boolean;
+        error?: string;
+        fixInstructions?: string;
+    }>;
+    protected buildCommand(context: TaskContext): CommandSpec;
+    protected handleLine(line: string, context: TaskContext, sink: EventSink): boolean;
+    private describeInput;
+    private describeError;
+    private reportFileOperation;
+    protected inspectFailureText(text: string): {
+        message: string;
+        authFailure?: boolean;
+    } | null;
+}
+export {};

package/dist/runtime/adapters/opencode-adapter.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * OpenCode Adapter
+ *
+ * Adapter for the OpenCode CLI (`opencode run`), an open-source local coding agent.
+ *
+ * Invocation: opencode run --format json -m <provider/model> [--session <ses_...>] <message>
+ * with cwd set to the project path. Output is a raw JSON event stream
+ * (step_start / tool_use / text / step_finish) normalized into BackendEvents.
+ *
+ * File changes are not trusted from the agent's report — the orchestrator's
+ * WorkspaceGuard diffs the project after the run and restores it before review.
+ *
+ * Reference: https://opencode.ai/docs/cli
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenCodeAdapter = void 0;
+const node_util_1 = require("node:util");
+const local_agent_adapter_1 = require("./local-agent-adapter");
+const execFileAsync = (0, node_util_1.promisify)(require("node:child_process").execFile);
+const FILE_INPUT_KEYS = ["filePath", "file_path", "path", "filename"];
+class OpenCodeAdapter extends local_agent_adapter_1.LocalAgentAdapter {
+    provider = "opencode";
+    constructor(config) {
+        super({ ...config, type: "local_agent", provider: "opencode" });
+    }
+    getCapabilities() {
+        return {
+            canStreamEvents: true,
+            canIsolateWorkspace: false,
+            providesStructuredDiffs: false,
+            supportsSessionContinuation: true,
+            supportsCancellation: true,
+            hasInternalLoop: true,
+            supportedFileOperations: "both",
+            canRunCommands: true,
+            authMethod: "cli_session",
+            forbiddenCommands: ["rm -rf /", "mkfs"],
+        };
+    }
+    get binary() {
+        return "opencode";
+    }
+    get installInstructions() {
+        return "Install OpenCode: npm install -g opencode-ai (or https://opencode.ai/docs). Then authenticate with 'opencode auth login'.";
+    }
+    get versionArgs() {
+        return ["--version"];
+    }
+    get supportsResume() {
+        return true;
+    }
+    async checkAuthentication() {
+        try {
+            const { stdout, stderr } = (await execFileAsync("opencode", ["providers", "list"], {
+                timeout: 12000,
+                windowsHide: true,
+            }));
+            const text = `${stdout}\n${stderr}`
+                .replace(/\u001b\[[0-9;]*m/g, "")
+                .replace(/\u001b\][^\u0007]*\u0007/g, "");
+            // The credentials section lists a "●" bullet per configured credential.
+            const credentialsStart = text.indexOf("Credentials");
+            const environmentStart = text.indexOf("Environment");
+            if (credentialsStart >= 0) {
+                const section = text.slice(credentialsStart, environmentStart > credentialsStart ? environmentStart : undefined);
+                if (!section.includes("●")) {
+                    return {
+                        authenticated: false,
+                        error: "OpenCode has no stored credentials.",
+                        fixInstructions: "Run 'opencode auth login' or set a provider API key (e.g. OPENCODE / OPENAI / ANTHROPIC keys).",
+                    };
+                }
+            }
+            return { authenticated: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                authenticated: false,
+                error: `Could not verify OpenCode authentication: ${message}`,
+                fixInstructions: "Run 'opencode providers list' manually and configure credentials with 'opencode auth login'.",
+            };
+        }
+    }
+    buildCommand(context) {
+        const resumeId = this.resumeSessionId(context);
+        const args = ["run", "--format", "json"];
+        if (this.modelId)
+            args.push("-m", this.modelId);
+        if (resumeId)
+            args.push("--session", resumeId);
+        args.push(this.buildTaskPrompt(context));
+        return { bin: "opencode", args, cwd: this.config.projectPath };
+    }
+    handleLine(line, context, sink) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            return false;
+        }
+        if (event.sessionID)
+            sink.state.sessionId = event.sessionID;
+        switch (event.type) {
+            case "step_start": {
+                sink.progress("OpenCode is working…");
+                return true;
+            }
+            case "tool_use": {
+                const part = event.part || {};
+                const toolName = part.tool || "tool";
+                const status = part.state?.status;
+                const input = part.state?.input || {};
+                if (status === "pending" || status === "running") {
+                    sink.toolStarted(toolName, this.describeInput(toolName, input));
+                }
+                else if (status === "completed") {
+                    sink.toolCompleted(toolName, true, this.describeInput(toolName, input));
+                    this.reportFileOperation(toolName, input, sink);
+                }
+                else if (status === "error") {
+                    sink.toolCompleted(toolName, false, this.describeInput(toolName, input));
+                    const errText = this.describeError(part.state?.error) || `${toolName} failed`;
+                    sink.error(errText, { recoverable: true });
+                }
+                return true;
+            }
+            case "text": {
+                const text = event.part?.text;
+                if (text)
+                    sink.progress(text);
+                return true;
+            }
+            case "step_finish": {
+                // A finished step marks the turn as complete; the exit code decides success.
+                sink.state.receivedTerminalSuccess = true;
+                return true;
+            }
+            case "error": {
+                const message = this.describeError(event.error) || "OpenCode reported an error";
+                sink.state.failureMessage = message;
+                sink.error(message, { recoverable: false });
+                return true;
+            }
+            default:
+                return true;
+        }
+    }
+    describeInput(toolName, input) {
+        if (typeof input.command === "string")
+            return input.command.slice(0, 200);
+        const key = FILE_INPUT_KEYS.find((k) => typeof input[k] === "string");
+        if (key)
+            return String(input[key]);
+        if (typeof input.pattern === "string")
+            return input.pattern;
+        return undefined;
+    }
+    describeError(error) {
+        if (!error)
+            return undefined;
+        if (typeof error === "string")
+            return error;
+        if (typeof error === "object") {
+            const e = error;
+            if (typeof e.message === "string")
+                return e.message;
+            if (typeof e.name === "string")
+                return e.name;
+            try {
+                return JSON.stringify(error).slice(0, 400);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return String(error);
+    }
+    reportFileOperation(toolName, input, sink) {
+        const key = FILE_INPUT_KEYS.find((k) => typeof input[k] === "string");
+        if (!key)
+            return;
+        const rel = this.relPath(String(input[key]));
+        const normalized = toolName.toLowerCase();
+        if (normalized.includes("write")) {
+            // Guard diff decides create vs modify.
+            sink.fileChange("modified", rel);
+        }
+        else if (normalized.includes("edit") || normalized.includes("patch")) {
+            sink.fileChange("modified", rel);
+        }
+        else if (normalized.includes("remove") || normalized.includes("delete")) {
+            sink.fileChange("deleted", rel);
+        }
+    }
+    inspectFailureText(text) {
+        if (!text)
+            return null;
+        if (/not logged in|authentication required|invalid api key|401|unauthorized/i.test(text)) {
+            return { message: "OpenCode authentication failed.", authFailure: true };
+        }
+        if (/rate limit|usage limit|quota exceeded/i.test(text)) {
+            return { message: "OpenCode provider rate limit or quota exceeded.", authFailure: true };
+        }
+        return null;
+    }
+}
+exports.OpenCodeAdapter = OpenCodeAdapter;