@opencraw/studio 0.0.34 → 0.0.37

package/dist/studio-api/ui-request.contract.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+/** What an outside controller (an agent, through the MCP server) can ask the open Studio page to do. Grows one `kind` at a time. */
+export declare const uiRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"open">;
+    path: z.ZodString;
+    workspace: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"pick">;
+    recipeId: z.ZodString;
+    selector: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    add: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>], "kind">;
+export type UiRequest = z.infer<typeof uiRequestSchema>;
+//# sourceMappingURL=ui-request.contract.d.ts.map

package/dist/studio-instance/index.d.ts

@@ -0,0 +1,3 @@
+export { announceInstance, defaultInstancesDirectory, withdrawInstance } from './instance-file.repository';
+export type { StudioInstance } from './studio-instance.contract';
+//# sourceMappingURL=index.d.ts.map

package/dist/studio-instance/instance-file.repository.d.ts

@@ -0,0 +1,14 @@
+import type { StudioInstance } from './studio-instance.contract';
+/** Where running Studios announce themselves, unless the caller says otherwise. */
+export declare function defaultInstancesDirectory(): string;
+/**
+ * Writes the file that tells controllers this Studio is running. Failing to write it never stops Studio: it only means no agent can find it.
+ *
+ * @param instance - What to announce.
+ * @param directory - Where announcements live.
+ * @returns Whether the file was written.
+ */
+export declare function announceInstance(instance: StudioInstance, directory: string): Promise<boolean>;
+/** Removes the announcement, when Studio stops. */
+export declare function withdrawInstance(instance: Pick<StudioInstance, 'pid' | 'url'>, directory: string): Promise<void>;
+//# sourceMappingURL=instance-file.repository.d.ts.map

package/dist/studio-instance/studio-instance.contract.d.ts

@@ -0,0 +1,15 @@
+/**
+ * What a running Studio tells the machine about itself, one file per process, so a controller that did not start it (the MCP server an
+ * agent talks to) can find it: `~/.opencraw/studio/<pid>.json`. The token is in it, so the file is readable by its owner only.
+ * `@opencraw/mcp` reads the same shape (`studio-control`); change both together.
+ */
+export interface StudioInstance {
+    pid: number;
+    /** The server's address, without the token: `http://127.0.0.1:<port>`. */
+    url: string;
+    token: string;
+    /** The folder Studio was started with, if any; the live one is asked with `studio-status`. */
+    folder?: string;
+    startedAt: string;
+}
+//# sourceMappingURL=studio-instance.contract.d.ts.map

package/dist/studio-server/ask-ui.handler.d.ts

@@ -0,0 +1,32 @@
+import type { AskUiCommand, AskUiView, UiOutcomeCommand, UiOutcomeView, UiReportCommand } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * Handles `ask-ui`: tells every open page what a controller (an agent, through the MCP server) asked for, so
+ * the person watching sees it happen. Nothing is done server-side: the page does it the way a click would, and
+ * says how it went (`ui-report`).
+ *
+ * @param state - The server state holding the connected pages.
+ * @param command - What to ask the pages.
+ * @returns How many pages were listening (0 means nobody has Studio open) and the id to ask the outcome with.
+ */
+export declare function handleAskUi(state: StudioState, command: AskUiCommand): AskUiView;
+/**
+ * Handles `ui-report`: a page says how a controller's request went. The first answer stays: every open page gets the
+ * request, and a page that has nothing to do with it (another recipe open) does not report.
+ *
+ * @param state - The server state.
+ * @param command - The request's id and the outcome.
+ * @returns Whether the report was kept.
+ */
+export declare function handleUiReport(state: StudioState, command: UiReportCommand): {
+    kept: boolean;
+};
+/**
+ * Handles `ui-outcome`: how a controller's request went.
+ *
+ * @param state - The server state.
+ * @param command - The request's id.
+ * @returns `pending` until a page reported, then what it said.
+ */
+export declare function handleUiOutcome(state: StudioState, command: UiOutcomeCommand): UiOutcomeView;
+//# sourceMappingURL=ask-ui.handler.d.ts.map

package/dist/studio-server/run-status.handler.d.ts

@@ -0,0 +1,12 @@
+import type { RunStatusCommand, RunStatusView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * Handles `run-status`: how a recipe's sample run is going, for a controller that started it and cannot watch
+ * the event stream. A run in progress is `running`; one that finished carries its counts and first records.
+ *
+ * @param state - The server state holding the run in progress and the last runs.
+ * @param command - The recipe asked about.
+ * @returns The state of the recipe's sample run.
+ */
+export declare function handleRunStatus(state: StudioState, command: RunStatusCommand): RunStatusView;
+//# sourceMappingURL=run-status.handler.d.ts.map

package/dist/studio-server/studio-http.use-case.d.ts

@@ -21,6 +21,8 @@ export interface StudioServerOptions {
     chooseFolder?: () => Promise<string | undefined>;
     /** Where the studio's own recorder profile lives (issue #95); default: a fixed directory under the OS temp folder, never a crawl's own profile directory, never the person's default browser. */
     recorderProfileDir?: string;
+    /** Where this Studio announces itself so an agent's MCP server can find it (`studio-instance`); default: `~/.opencraw/studio`. */
+    instancesDir?: string;
 }
 /** The running server: its URL (token included, ready to open), the token alone, and how to stop it. */
 export interface StudioServer {

package/dist/studio-server/studio-status.handler.d.ts

@@ -0,0 +1,10 @@
+import type { StudioStatusView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * Handles `studio-status`: what Studio is doing right now.
+ *
+ * @param state - The server state.
+ * @returns The open workspace, how many pages are open and the recipe being sampled.
+ */
+export declare function handleStudioStatus(state: StudioState): StudioStatusView;
+//# sourceMappingURL=studio-status.handler.d.ts.map

package/dist/studio-server/workspace.store.d.ts

@@ -2,17 +2,21 @@ import type { BrowserSessionConfig } from '@opencraw/core';
 import type { RecorderSessionHandle } from '../flow-recording';
 import type { SnapshotCache } from '../page-snapshot';
 import type { LastRunCache, SampleRunHandle } from '../sample-run';
-import type { StudioEvent } from '../studio-api';
+import type { StudioEvent, UiOutcomeView } from '../studio-api';
 import type { TrustedPlugins } from '../trusted-plugins';
 import type { WsConnection } from './websocket.client';
 /** The server's mutable state: the opened folder, the run in progress (if any), the recording in progress (if any, issue #95), the connected event sockets, the per-recipe snapshot cache `take-snapshot`/`verify-selector`/`infer-selector` share, each recipe's last finished sample run (`explain-why`, issue #92), the browser launch settings every web-mode command (`take-snapshot`, `verify-selector`, `run-sample`, `start-recording`) shares, and where the studio's own recorder profile lives. */
 export interface StudioState {
     folder?: string;
     activeRun?: SampleRunHandle;
+    /** The recipe `activeRun` is sampling. */
+    activeRunId?: string;
     activeRecording?: RecorderSessionHandle;
     /** A `start-recording` still opening its window: `stop-recording` and the server's own close wait for it, so a window is never left open behind them (issue #174). */
     openingRecording?: Promise<unknown>;
     sockets: Set<WsConnection>;
+    /** How the pages said a controller's requests went (`ui-report`), by request id; the oldest are dropped past a few dozen. */
+    uiOutcomes: Map<string, UiOutcomeView>;
     snapshots: SnapshotCache;
     lastRuns: LastRunCache;
     /** Set once at server start (`StudioServerOptions.browser`); every web-mode command reads it from here rather than each accepting its own. */