mstro-app 0.5.1 → 0.5.6

package/dist/server/engines/factory.js

@@ -0,0 +1,152 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+/**
+ * Engine factory — returns a concrete CodingAgentEngine for the requested
+ * EngineId. Callers pass the value of `settings.engine` and the factory
+ * dispatches to the matching implementation:
+ *
+ *   - 'claude-code' → ClaudeCodeEngine (headless runner, stdout JSON)
+ *   - 'opencode'    → OpenCodeEngine   (OpenCode SDK + SSE)
+ *
+ * The OpenCode path is backed by a single process-lifetime
+ * OpenCodeServerManager that owns the `opencode serve` subprocess. The
+ * factory itself stays synchronous; manager startup is awaited inside
+ * `startSession` via `LazyOpenCodeEngine` (below) so callers observe the
+ * same lifecycle as ClaudeCodeEngine.
+ */
+import { isEngineSwapEnabled } from '../services/settings.js';
+import { ClaudeCodeEngine } from './claude/ClaudeCodeEngine.js';
+import { OpenCodeEngine } from './opencode/OpenCodeEngine.js';
+import { OpenCodeServerManager } from './opencode/OpenCodeServerManager.js';
+/**
+ * Process-lifetime singleton for the `opencode serve` subprocess. Created
+ * lazily on the first request for an opencode engine so Claude-only
+ * deployments never spawn the binary. `registerProcessHandlers` is set so
+ * the subprocess exits with the CLI — no orphan processes on SIGINT.
+ */
+let sharedOpenCodeManager = null;
+function getSharedOpenCodeServerManager() {
+    if (!sharedOpenCodeManager) {
+        sharedOpenCodeManager = new OpenCodeServerManager({
+            registerProcessHandlers: true,
+        });
+    }
+    return sharedOpenCodeManager;
+}
+/**
+ * Reset the cached OpenCode manager. Primarily for tests — never called
+ * by production code. Does not shut down the previous manager; callers
+ * that need a clean state should `shutdown()` first.
+ */
+export function __resetSharedOpenCodeServerManagerForTests() {
+    sharedOpenCodeManager = null;
+}
+/**
+ * Thin adapter that defers `OpenCodeEngine` construction until
+ * `startSession` runs. The real engine requires an already-bound
+ * `OpencodeClient`, but the underlying HTTP server is spawned
+ * asynchronously by `OpenCodeServerManager`. `startSession` is the first
+ * async call on the engine lifecycle, so we await `manager.start()`
+ * there, then construct the inner engine once the client is available
+ * and forward every subsequent call to it.
+ *
+ * The wrapper preserves the public `CodingAgentEngine` contract:
+ *   - `engineId` is stable at `'opencode'` from construction.
+ *   - Methods called before `startSession` resolve reject with the same
+ *     error wording the inner engine would have produced.
+ *   - `dispose()` is idempotent and tolerates the uninitialized case.
+ */
+class LazyOpenCodeEngine {
+    manager;
+    engineId = 'opencode';
+    inner = null;
+    started = false;
+    disposed = false;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    async startSession(options) {
+        if (this.disposed) {
+            throw new Error('OpenCodeEngine: cannot start a disposed engine');
+        }
+        if (this.started) {
+            throw new Error('OpenCodeEngine: startSession called more than once');
+        }
+        await this.manager.start();
+        const client = this.manager.getClient();
+        this.inner = new OpenCodeEngine({
+            client,
+            directory: options.workingDir,
+        });
+        await this.inner.startSession(options);
+        this.started = true;
+    }
+    sendPrompt(prompt, attachments) {
+        if (this.disposed) {
+            return Promise.reject(new Error('OpenCodeEngine: sendPrompt called after dispose'));
+        }
+        if (!this.inner) {
+            return Promise.reject(new Error('OpenCodeEngine: sendPrompt called before startSession'));
+        }
+        return this.inner.sendPrompt(prompt, attachments);
+    }
+    cancel() {
+        if (!this.inner)
+            return Promise.resolve();
+        return this.inner.cancel();
+    }
+    getUsage() {
+        if (!this.inner) {
+            return { inputTokens: 0, outputTokens: 0, lastUpdatedAt: Date.now() };
+        }
+        return this.inner.getUsage();
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        if (this.inner) {
+            await this.inner.dispose();
+        }
+    }
+    [Symbol.asyncIterator]() {
+        // The contract only allows iteration after `startSession` has resolved,
+        // so `this.inner` is guaranteed to be set when consumers begin the
+        // for-await loop. We delegate directly to the inner engine's iterator
+        // to preserve its ordering and terminal-event semantics.
+        if (!this.inner) {
+            return {
+                next: () => Promise.resolve({ value: undefined, done: true }),
+            };
+        }
+        return this.inner[Symbol.asyncIterator]();
+    }
+}
+/**
+ * Construct a new engine instance for the given engine id. The returned
+ * engine is uninitialized — the caller must call `startSession` before
+ * any other method.
+ *
+ * Feature-flag gate: when `engineSwap` is disabled, this returns
+ * `ClaudeCodeEngine` for every id. That guarantees the pre-OpenCode
+ * behavior — in particular, `LazyOpenCodeEngine` is never constructed, so
+ * the shared `OpenCodeServerManager` is never touched and no `opencode
+ * serve` subprocess is spawned. The flag is checked on every call (rather
+ * than cached) so runtime toggles take effect on the next session start.
+ */
+export function createEngine(engineId) {
+    if (!isEngineSwapEnabled()) {
+        return new ClaudeCodeEngine();
+    }
+    switch (engineId) {
+        case 'claude-code':
+            return new ClaudeCodeEngine();
+        case 'opencode':
+            return new LazyOpenCodeEngine(getSharedOpenCodeServerManager());
+        default: {
+            const exhaustive = engineId;
+            throw new Error(`Unknown engine id: ${String(exhaustive)}`);
+        }
+    }
+}
+//# sourceMappingURL=factory.js.map

package/dist/server/engines/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../../server/engines/factory.ts"],"names":[],"mappings":"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"}

package/dist/server/engines/opencode/OpenCodeEngine.d.ts

@@ -0,0 +1,148 @@
+/**
+ * OpenCodeEngine
+ *
+ * Adapter that wraps the OpenCode SDK (@opencode-ai/sdk) behind the
+ * CodingAgentEngine interface. Owns a single OpenCode `session` per Mstro
+ * improvisation:
+ *
+ * - `startSession` creates (or resumes) an OpenCode session and opens an
+ *   SSE subscription to `/event`. A background pump consumes the stream
+ *   and translates each payload into the engine-agnostic `EngineEvent`
+ *   shape so the rest of the system does not need to know which engine
+ *   produced the events.
+ * - `sendPrompt` dispatches `session.promptAsync` and resolves as soon as
+ *   the server has accepted the prompt. Streaming output arrives via SSE.
+ * - `cancel` calls `session.abort`, which the OpenCode server eventually
+ *   reflects back as a `session.idle` event.
+ * - `dispose` stops the pump and deletes the underlying session.
+ *
+ * The concrete SSE → EngineEvent mapping is documented inline in
+ * `handleSseEvent`.
+ */
+import type { OpencodeClient } from '@opencode-ai/sdk';
+import { type BouncerDecision, type EnginePermissionReviewRequest } from '../../mcp/bouncer-integration.js';
+import type { EngineEvent, EngineId } from '../EngineEvent.js';
+import type { CodingAgentEngine, EngineUsage, PromptAttachment, StartSessionOptions } from '../types.js';
+/**
+ * Bouncer entry-point signature. Exposed as an option on OpenCodeEngine so
+ * tests can swap in a stub without patching module internals. Production
+ * code passes `reviewEnginePermission` from bouncer-integration.ts, which
+ * in turn calls {@link reviewOperation} — the single source of truth for
+ * security decisions across every engine.
+ */
+export type ReviewEnginePermissionFn = (request: EnginePermissionReviewRequest) => Promise<BouncerDecision>;
+/** Construction-time dependencies for {@link OpenCodeEngine}. */
+export interface OpenCodeEngineOptions {
+    /**
+     * Typed SDK client, already bound to a running opencode server. Usually
+     * obtained from `OpenCodeServerManager.getClient()`. Tests inject a
+     * hand-rolled mock matching the subset of methods used here.
+     */
+    client: OpencodeClient;
+    /**
+     * Directory query parameter forwarded to each request. OpenCode scopes
+     * sessions and events by directory — the value is typically the same
+     * working directory passed to `startSession`.
+     */
+    directory?: string;
+    /**
+     * Override the bouncer review function. Defaults to
+     * `reviewEnginePermission` from `cli/server/mcp/bouncer-integration.ts`
+     * — which wraps the unified {@link reviewOperation} entry point used by
+     * the Claude MCP path. Tests inject a stub to drive specific decisions.
+     */
+    reviewPermission?: ReviewEnginePermissionFn;
+}
+export declare class OpenCodeEngine implements CodingAgentEngine {
+    readonly engineId: EngineId;
+    private readonly client;
+    private readonly directory;
+    private readonly reviewPermission;
+    private sessionOptions;
+    private openCodeSessionId;
+    /** True once the caller has called `startSession` successfully. */
+    private started;
+    /** Active SSE subscription returned by `client.event.subscribe()`. */
+    private subscription;
+    /** Background task consuming `subscription.stream`. */
+    private pumpPromise;
+    /** In-flight prompt promise — enforces the one-prompt-at-a-time contract. */
+    private currentPromptPromise;
+    private disposed;
+    private iteratorDone;
+    private readonly queue;
+    private readonly pending;
+    /**
+     * Tool-call id → start timestamp. Populated on the first `running`
+     * state of a ToolPart so we can compute `durationMs` when the part
+     * transitions to `completed` or `error`.
+     */
+    private readonly toolStartTimes;
+    /**
+     * Tool-call ids we have already announced via `tool.start`. Prevents
+     * duplicate starts when OpenCode emits multiple `running` updates.
+     */
+    private readonly toolStarted;
+    private usage;
+    constructor(options: OpenCodeEngineOptions);
+    startSession(options: StartSessionOptions): Promise<void>;
+    sendPrompt(prompt: string, _attachments?: PromptAttachment[]): Promise<void>;
+    cancel(): Promise<void>;
+    getUsage(): EngineUsage;
+    dispose(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterator<EngineEvent>;
+    private sessionIdForEvent;
+    private emit;
+    private closeIterator;
+    /**
+     * Long-running task that consumes the SSE stream. Exits when the stream
+     * ends naturally (dispose called `stream.return()`) or when an error
+     * propagates out of the generator.
+     */
+    private runEventPump;
+    /**
+     * Core mapping from OpenCode SSE events to EngineEvents.
+     *
+     * - message.part.updated (TextPart)        → message.delta
+     * - message.part.updated (ReasoningPart)   → message.thinking
+     * - message.part.updated (ToolPart running) → tool.start  (once per callID)
+     * - message.part.updated (ToolPart done)    → tool.end
+     * - message.part.updated (StepFinishPart)   → usage.update
+     * - message.updated (AssistantMessage)     → usage.update (if tokens set)
+     * - permission.updated                     → permission.request
+     * - session.idle                           → session.idle
+     * - session.error                          → engine.error
+     *
+     * Events for sessions other than the one we own are ignored so that a
+     * shared server emitting events for multiple clients does not cross
+     * streams.
+     */
+    private handleSseEvent;
+    /**
+     * Route an OpenCode `permission.updated` through the unified Bouncer
+     * and respond to the SDK so the server never hangs waiting.
+     *
+     * Contract:
+     * - Approval (allow / warn_allow) → SDK `{ response: 'once' }`.
+     * - Denial (deny)                 → SDK `{ response: 'reject' }` *and*
+     *   a user-visible `engine.error` carrying the same message the Claude
+     *   MCP path returns on a deny (see `cli/server/mcp/server.ts`), so
+     *   both engines surface denials with identical wording.
+     *
+     * Any error — bouncer failure, SDK failure — is treated as a deny for
+     * safety: we tell OpenCode `reject`, emit an engine.error, and keep the
+     * session alive (non-fatal).
+     */
+    private resolvePermission;
+    private reviewPermissionSafely;
+    private handlePartUpdated;
+    private onTextPart;
+    private onReasoningPart;
+    private onToolPart;
+    private emitToolStartOnce;
+    private emitToolEnd;
+    private onStepFinish;
+    private handleMessageUpdated;
+    private applyTokens;
+}
+//# sourceMappingURL=OpenCodeEngine.d.ts.map

package/dist/server/engines/opencode/OpenCodeEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenCodeEngine.d.ts","sourceRoot":"","sources":["../../../../server/engines/opencode/OpenCodeEngine.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAGV,cAAc,EAQf,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,6BAA6B,EAGnC,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAC9D,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,aAAa,CAAA;AAEpB;;;;;;GAMG;AACH,MAAM,MAAM,wBAAwB,GAAG,CACrC,OAAO,EAAE,6BAA6B,KACnC,OAAO,CAAC,eAAe,CAAC,CAAA;AAc7B,iEAAiE;AACjE,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,MAAM,EAAE,cAAc,CAAA;IACtB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,wBAAwB,CAAA;CAC5C;AAqBD,qBAAa,cAAe,YAAW,iBAAiB;IACtD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAa;IAExC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA0B;IAE3D,OAAO,CAAC,cAAc,CAAmC;IACzD,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,mEAAmE;IACnE,OAAO,CAAC,OAAO,CAAQ;IAEvB,sEAAsE;IACtE,OAAO,CAAC,YAAY,CAAiC;IACrD,uDAAuD;IACvD,OAAO,CAAC,WAAW,CAA6B;IAEhD,6EAA6E;IAC7E,OAAO,CAAC,oBAAoB,CAA6B;IAEzD,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IAEzC;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiC;IAChE;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyB;IAErD,OAAO,CAAC,KAAK,CAIZ;gBAEW,OAAO,EAAE,qBAAqB;IASpC,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgCzD,UAAU,CACd,MAAM,EAAE,MAAM,EACd,YAAY,CAAC,EAAE,gBAAgB,EAAE,GAChC,OAAO,CAAC,IAAI,CAAC;IAmCV,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB7B,QAAQ,IAAI,WAAW;IAIjB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAwC9B,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,WAAW,CAAC;IAyBpD,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,IAAI;IAaZ,OAAO,CAAC,aAAa;IASrB;;;;OAIG;YACW,YAAY;IAsB1B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,cAAc;IAmEtB;;;;;;;;;;;;;;OAcG;YACW,iBAAiB;YA4CjB,sBAAsB;IAyBpC,OAAO,CAAC,iBAAiB;IAmBzB,OAAO,CAAC,UAAU;IAgBlB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,UAAU;IAclB,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,WAAW;IAyBnB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,WAAW;CA0CpB"}