@secondlayer/sdk 0.10.3 → 1.0.1

package/README.md

@@ -19,27 +19,6 @@ const sl = new SecondLayer({
 });
 ```
 
-## Streams
-
-Manage real-time event streams with endpoint delivery.
-
-```typescript
-// Create
-const { stream, signingSecret } = await sl.streams.create({
-  name: "my-stream",
-  endpointUrl: "https://example.com/receive",
-  filters: { type: "contract_call", contract_id: "SP...token" },
-});
-
-// List
-const { streams, total } = await sl.streams.list({ status: "active" });
-
-// Get / Update / Delete
-const stream = await sl.streams.get("stream-id");
-await sl.streams.update("stream-id", { name: "renamed" });
-await sl.streams.delete("stream-id");
-```
-
 ## Subgraphs
 
 Deploy and query subgraphs (custom indexers).
@@ -101,7 +80,7 @@ const run = await sl.workflows.getRun("run-id");
 import { ApiError } from "@secondlayer/sdk";
 
 try {
-  await sl.streams.get("nonexistent");
+  await sl.subgraphs.get("nonexistent");
 } catch (err) {
   if (err instanceof ApiError) {
     console.log(err.status);  // 404

package/dist/index.d.ts

@@ -4,10 +4,13 @@ interface SecondLayerOptions {
 	baseUrl: string;
 	/** Bearer token for authenticated requests. */
 	apiKey?: string;
+	/** Deploy origin label sent as `x-sl-origin` (telemetry). Defaults to `cli`. */
+	origin?: "cli" | "mcp" | "session";
 }
 declare abstract class BaseClient {
 	protected baseUrl: string;
 	protected apiKey?: string;
+	protected origin: "cli" | "mcp" | "session";
 	constructor(options?: Partial<SecondLayerOptions>);
 	static authHeaders(apiKey?: string): Record<string, string>;
 	protected request<T>(method: string, path: string, body?: unknown): Promise<T>;
@@ -45,52 +48,28 @@ declare class Marketplace extends BaseClient {
 		}
 	}>;
 }
-import { BulkPauseResponse, BulkResumeResponse, CreateStream, CreateStreamResponse, ListStreamsResponse, StreamResponse, UpdateStream } from "@secondlayer/shared/schemas";
-interface DeliverySummary {
-	id: string;
-	blockHeight: number;
-	status: string;
-	statusCode: number | null;
-	responseTimeMs: number | null;
-	attempts: number;
-	error: string | null;
-	createdAt: string;
-}
-interface DeliveryDetail extends DeliverySummary {
-	payload: unknown;
-}
-interface DeliveriesResponse {
-	deliveries: DeliverySummary[];
-}
-declare class Streams extends BaseClient {
-	private requestWithStreamId;
-	resolveStreamId(partialId: string): Promise<string>;
-	create(data: CreateStream): Promise<CreateStreamResponse>;
-	update(id: string, data: UpdateStream): Promise<StreamResponse>;
-	updateByName(name: string, data: CreateStream): Promise<StreamResponse>;
-	list(params?: {
-		status?: string
-	}): Promise<ListStreamsResponse>;
-	get(id: string): Promise<StreamResponse>;
-	delete(id: string): Promise<void>;
-	enable(id: string): Promise<StreamResponse>;
-	disable(id: string): Promise<StreamResponse>;
-	rotateSecret(id: string): Promise<{
-		secret: string
-	}>;
-	/** List recent deliveries for a stream. */
-	listDeliveries(id: string, params?: {
-		limit?: number
-		status?: string
-	}): Promise<DeliveriesResponse>;
-	/** Get a single delivery with full payload. */
-	getDelivery(streamId: string, deliveryId: string): Promise<DeliveryDetail>;
-	pauseAll(): Promise<BulkPauseResponse>;
-	resumeAll(): Promise<BulkResumeResponse>;
-}
 import { ReindexResponse, SubgraphDetail, SubgraphGapsResponse, SubgraphQueryParams as SubgraphQueryParams2, SubgraphSummary } from "@secondlayer/shared/schemas";
 import { DeploySubgraphRequest, DeploySubgraphResponse } from "@secondlayer/shared/schemas/subgraphs";
 import { InferSubgraphClient } from "@secondlayer/subgraphs";
+interface SubgraphSource {
+	name: string;
+	version: string;
+	sourceCode: string | null;
+	readOnly: boolean;
+	reason?: string;
+	updatedAt: string;
+}
+interface BundleSubgraphResponse {
+	ok: true;
+	name: string;
+	version: string | null;
+	description: string | null;
+	sources: Record<string, Record<string, unknown>>;
+	schema: Record<string, unknown>;
+	handlerCode: string;
+	sourceCode: string;
+	bundleSize: number;
+}
 declare class Subgraphs extends BaseClient {
 	list(): Promise<{
 		data: SubgraphSummary[]
@@ -116,6 +95,14 @@ declare class Subgraphs extends BaseClient {
 		message: string
 	}>;
 	deploy(data: DeploySubgraphRequest): Promise<DeploySubgraphResponse>;
+	getSource(name: string): Promise<SubgraphSource>;
+	/**
+	* Bundle a TypeScript subgraph source on the server. Used by the web chat
+	* authoring loop so Vercel's serverless runtime doesn't have to run esbuild.
+	*/
+	bundle(data: {
+		code: string
+	}): Promise<BundleSubgraphResponse>;
 	queryTable(name: string, table: string, params?: SubgraphQueryParams2): Promise<unknown[]>;
 	queryTableCount(name: string, table: string, params?: SubgraphQueryParams2): Promise<{
 		count: number
@@ -139,12 +126,78 @@ declare class Subgraphs extends BaseClient {
 	private createTableClient;
 }
 import { InferSubgraphClient as InferSubgraphClient2 } from "@secondlayer/subgraphs";
-import { QueueStats } from "@secondlayer/shared/types";
 import { WorkflowRun, WorkflowRunStatus } from "@secondlayer/workflows";
+interface WorkflowSource {
+	name: string;
+	version: string;
+	sourceCode: string | null;
+	readOnly: boolean;
+	reason?: string;
+	updatedAt: string;
+}
+interface WorkflowStepEvent {
+	id: string;
+	stepIndex: number;
+	stepId: string;
+	stepType: string;
+	status: string;
+	output?: unknown;
+	error: string | null;
+	retryCount: number;
+	aiTokensUsed: number;
+	startedAt: string | null;
+	completedAt: string | null;
+	durationMs: number | null;
+	ts: string;
+}
+interface WorkflowRunDoneEvent {
+	runId: string;
+	status: string;
+	error?: string | null;
+	completedAt?: string | null;
+}
+type WorkflowTailEvent = {
+	type: "step"
+	step: WorkflowStepEvent
+} | {
+	type: "done"
+	done: WorkflowRunDoneEvent
+} | {
+	type: "heartbeat"
+	ts: string
+} | {
+	type: "timeout"
+	message: string
+};
+interface DeployDryRunResponse {
+	valid: boolean;
+	validation?: {
+		name: string
+		triggerType: string
+	};
+	bundleSize: number;
+	error?: string;
+}
+interface DeployResponse {
+	action: "created" | "updated";
+	workflowId: string;
+	version: string;
+	message: string;
+}
+interface BundleWorkflowResponse {
+	ok: true;
+	name: string;
+	trigger: Record<string, unknown>;
+	handlerCode: string;
+	sourceCode: string;
+	retries: Record<string, unknown> | null;
+	timeout: number | null;
+	bundleSize: number;
+}
 interface WorkflowSummary {
 	name: string;
 	status: "active" | "paused";
-	triggerType: "event" | "stream" | "schedule" | "manual";
+	triggerType: "event" | "schedule" | "manual";
 	createdAt: string;
 	updatedAt: string;
 }
@@ -172,13 +225,63 @@ declare class Workflows extends BaseClient {
 		name: string
 		trigger: Record<string, unknown>
 		handlerCode: string
+		sourceCode?: string
+		expectedVersion?: string
 		retries?: Record<string, unknown>
 		timeout?: number
-	}): Promise<{
-		action: string
-		workflowId: string
-		message: string
+		clientRequestId?: string
+	} & {
+		dryRun?: false
+	}): Promise<DeployResponse>;
+	deploy(data: {
+		name: string
+		trigger: Record<string, unknown>
+		handlerCode: string
+		sourceCode?: string
+		expectedVersion?: string
+		retries?: Record<string, unknown>
+		timeout?: number
+		dryRun: true
+	}): Promise<DeployDryRunResponse>;
+	getSource(name: string): Promise<WorkflowSource>;
+	/**
+	* Bundle a TypeScript workflow source on the server. Used by the web chat
+	* authoring loop so Vercel's serverless runtime doesn't have to run esbuild.
+	* CLI and MCP still bundle locally — this method is for clients that can't
+	* install `@secondlayer/bundler` directly (e.g. browser tooling, edge
+	* functions).
+	*/
+	bundle(data: {
+		code: string
+	}): Promise<BundleWorkflowResponse>;
+	pauseAll(): Promise<{
+		paused: number
+		workflows: Array<{
+			name: string
+			version: string
+			status: string
+		}>
 	}>;
+	cancelRun(runId: string): Promise<{
+		runId: string
+		status: string
+		cancelled: boolean
+		completedAt?: string
+		message?: string
+	}>;
+	rollback(name: string, toVersion?: string): Promise<{
+		action: "rolled-back"
+		name: string
+		fromVersion: string
+		restoredFromVersion: string
+		version: string
+	}>;
+	/**
+	* Subscribe to a workflow run's server-sent event stream. Resolves when the
+	* run completes, times out, or the signal is aborted. Throws on HTTP errors
+	* opening the stream.
+	*/
+	streamRun(name: string, runId: string, onEvent: (event: WorkflowTailEvent) => void, signal?: AbortSignal): Promise<void>;
 	list(): Promise<{
 		workflows: WorkflowSummary[]
 	}>;
@@ -198,12 +301,10 @@ declare class Workflows extends BaseClient {
 	getRun(runId: string): Promise<WorkflowRun>;
 }
 declare class SecondLayer extends BaseClient {
-	readonly streams: Streams;
 	readonly subgraphs: Subgraphs;
 	readonly marketplace: Marketplace;
 	readonly workflows: Workflows;
 	constructor(options?: Partial<SecondLayerOptions>);
-	getQueueStats(): Promise<QueueStats>;
 }
 /**
 * Returns a typed client for a subgraph defined with `defineSubgraph()`.
@@ -230,10 +331,10 @@ declare function getSubgraph<T extends {
 * @example
 * ```ts
 * try {
-*   await client.streams.get("abc123");
+*   await client.subgraphs.get("my-subgraph");
 * } catch (err) {
 *   if (err instanceof ApiError && err.status === 404) {
-*     console.log("Stream not found");
+*     console.log("Subgraph not found");
 *   }
 * }
 * ```
@@ -241,7 +342,18 @@ declare function getSubgraph<T extends {
 declare class ApiError extends Error {
 	/** HTTP status code (0 for network errors). */
 	status: number;
-	constructor(status: number, message: string);
+	/** Raw response body (parsed JSON if possible) — preserved for callers that need error details. */
+	body?: unknown;
+	constructor(status: number, message: string, body?: unknown);
+}
+/**
+* Thrown by {@link Workflows.deploy} when the server rejects a deploy because the
+* provided `expectedVersion` does not match the current stored version.
+*/
+declare class VersionConflictError extends ApiError {
+	currentVersion: string;
+	expectedVersion: string;
+	constructor(currentVersion: string, expectedVersion: string, message?: string);
 }
 /**
 * Verify a webhook delivery signature from Secondlayer.
@@ -252,7 +364,7 @@ declare class ApiError extends Error {
 *
 * @param rawBody - The raw request body as a string (not parsed JSON)
 * @param signatureHeader - The value of the `x-secondlayer-signature` header
-* @param secret - Your stream's signing secret
+* @param secret - Your signing secret
 * @param toleranceSeconds - Max age of signature in seconds (default 300)
 * @returns true if the signature is valid
 *
@@ -271,4 +383,4 @@ declare class ApiError extends Error {
 * ```
 */
 declare function verifyWebhookSignature(rawBody: string, signatureHeader: string, secret: string, toleranceSeconds?: number): boolean;
-export { verifyWebhookSignature, getSubgraph, Workflows, Subgraphs, Streams, SecondLayerOptions, SecondLayer, Marketplace, ApiError };
+export { verifyWebhookSignature, getSubgraph, VersionConflictError, Subgraphs, SecondLayerOptions, SecondLayer, Marketplace, ApiError };

package/dist/index.js

@@ -1,35 +1,51 @@
 // src/errors.ts
 class ApiError extends Error {
   status;
-  constructor(status, message) {
+  body;
+  constructor(status, message, body) {
     super(message);
     this.status = status;
+    this.body = body;
     this.name = "ApiError";
   }
 }
 
+class VersionConflictError extends ApiError {
+  currentVersion;
+  expectedVersion;
+  constructor(currentVersion, expectedVersion, message = `Version conflict: expected ${expectedVersion}, current ${currentVersion}`) {
+    super(409, message, { currentVersion, expectedVersion });
+    this.currentVersion = currentVersion;
+    this.expectedVersion = expectedVersion;
+    this.name = "VersionConflictError";
+  }
+}
+
 // src/base.ts
 var DEFAULT_BASE_URL = "https://api.secondlayer.tools";
 
 class BaseClient {
   baseUrl;
   apiKey;
+  origin;
   constructor(options = {}) {
     this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
     this.apiKey = options.apiKey;
+    this.origin = options.origin ?? "cli";
   }
   static authHeaders(apiKey) {
     const headers = {
       "Content-Type": "application/json"
     };
     if (apiKey) {
-      headers["Authorization"] = `Bearer ${apiKey}`;
+      headers.Authorization = `Bearer ${apiKey}`;
     }
     return headers;
   }
   async request(method, path, body) {
     const url = `${this.baseUrl}${path}`;
     const headers = BaseClient.authHeaders(this.apiKey);
+    headers["x-sl-origin"] = this.origin;
     let response;
     try {
       response = await fetch(url, {
@@ -54,8 +70,10 @@ class BaseClient {
       }
       const errorBody = await response.text();
       let message = `HTTP ${response.status}`;
+      let parsedBody = errorBody;
       try {
         const json = JSON.parse(errorBody);
+        parsedBody = json;
         const err = json.error ?? json.message;
         if (typeof err === "string") {
           message = err;
@@ -66,7 +84,7 @@ class BaseClient {
         if (errorBody)
           message = errorBody;
       }
-      throw new ApiError(response.status, message);
+      throw new ApiError(response.status, message, parsedBody);
     }
     if (response.status === 204) {
       return;
@@ -131,83 +149,6 @@ class Marketplace extends BaseClient {
     return this.request("GET", `/api/marketplace/subgraphs/${name}/${table}${buildSubgraphQueryString(params)}`);
   }
 }
-// src/streams/client.ts
-class Streams extends BaseClient {
-  async requestWithStreamId(method, pathTemplate, id, body) {
-    const fullId = await this.resolveStreamId(id);
-    return this.request(method, pathTemplate(fullId), body);
-  }
-  async resolveStreamId(partialId) {
-    if (partialId.length === 36 && partialId.includes("-")) {
-      return partialId;
-    }
-    const { streams } = await this.list();
-    const matches = streams.filter((s) => s.id.startsWith(partialId));
-    if (matches.length === 0) {
-      throw new ApiError(404, `No stream found matching "${partialId}"`);
-    }
-    if (matches.length > 1) {
-      throw new ApiError(400, `Multiple streams match "${partialId}": ${matches.map((s) => s.id.slice(0, 8)).join(", ")}`);
-    }
-    return matches[0].id;
-  }
-  async create(data) {
-    return this.request("POST", "/api/streams", data);
-  }
-  async update(id, data) {
-    return this.requestWithStreamId("PATCH", (id2) => `/api/streams/${id2}`, id, data);
-  }
-  async updateByName(name, data) {
-    const { streams } = await this.list();
-    const existing = streams.find((s) => s.name === name);
-    if (!existing) {
-      throw new ApiError(404, `Stream with name "${name}" not found`);
-    }
-    return this.update(existing.id, data);
-  }
-  async list(params) {
-    const searchParams = new URLSearchParams;
-    if (params?.status)
-      searchParams.set("status", params.status);
-    const query = searchParams.toString();
-    const path = query ? `/api/streams?${query}` : "/api/streams";
-    return this.request("GET", path);
-  }
-  async get(id) {
-    return this.requestWithStreamId("GET", (id2) => `/api/streams/${id2}`, id);
-  }
-  async delete(id) {
-    return this.requestWithStreamId("DELETE", (id2) => `/api/streams/${id2}`, id);
-  }
-  async enable(id) {
-    return this.requestWithStreamId("POST", (id2) => `/api/streams/${id2}/enable`, id);
-  }
-  async disable(id) {
-    return this.requestWithStreamId("POST", (id2) => `/api/streams/${id2}/disable`, id);
-  }
-  async rotateSecret(id) {
-    return this.requestWithStreamId("POST", (id2) => `/api/streams/${id2}/rotate-secret`, id);
-  }
-  async listDeliveries(id, params) {
-    const qs = new URLSearchParams;
-    if (params?.limit !== undefined)
-      qs.set("limit", String(params.limit));
-    if (params?.status)
-      qs.set("status", params.status);
-    const query = qs.toString();
-    return this.requestWithStreamId("GET", (id2) => `/api/streams/${id2}/deliveries${query ? `?${query}` : ""}`, id);
-  }
-  async getDelivery(streamId, deliveryId) {
-    const fullId = await this.resolveStreamId(streamId);
-    return this.request("GET", `/api/streams/${fullId}/deliveries/${deliveryId}`);
-  }
-  async pauseAll() {
-    return this.request("POST", "/api/streams/pause");
-  }
-  async resumeAll() {
-    return this.request("POST", "/api/streams/resume");
-  }
-}
 // src/subgraphs/serialize.ts
 var SYSTEM_COLUMN_MAP = {
   _blockHeight: "_block_height",
@@ -304,6 +245,12 @@ class Subgraphs extends BaseClient {
   async deploy(data) {
     return this.request("POST", "/api/subgraphs", data);
   }
+  async getSource(name) {
+    return this.request("GET", `/api/subgraphs/${name}/source`);
+  }
+  async bundle(data) {
+    return this.request("POST", "/api/subgraphs/bundle", data);
+  }
   async queryTable(name, table, params = {}) {
     const result = await this.request("GET", `/api/subgraphs/${name}/${table}${buildSubgraphQueryString2(params)}`);
     return Array.isArray(result) ? result : result.data;
@@ -358,9 +305,116 @@ class Subgraphs extends BaseClient {
   }
 }
 // src/workflows/client.ts
+function parseSseChunk(raw) {
+  let event = "message";
+  const dataLines = [];
+  for (const line of raw.split(`
+`)) {
+    if (line.startsWith("event:")) {
+      event = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trimStart());
+    }
+  }
+  if (dataLines.length === 0)
+    return null;
+  const data = dataLines.join(`
+`);
+  try {
+    const parsed = JSON.parse(data);
+    switch (event) {
+      case "step":
+        return { type: "step", step: parsed };
+      case "done":
+        return { type: "done", done: parsed };
+      case "heartbeat":
+        return {
+          type: "heartbeat",
+          ts: typeof parsed === "string" ? parsed : String(parsed)
+        };
+      case "timeout":
+        return {
+          type: "timeout",
+          message: parsed.message ?? "timeout"
+        };
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+
 class Workflows extends BaseClient {
   async deploy(data) {
-    return this.request("POST", "/api/workflows", data);
+    try {
+      return await this.request("POST", "/api/workflows", data);
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 409) {
+        const body = err.body;
+        if (body?.currentVersion && body.expectedVersion) {
+          throw new VersionConflictError(body.currentVersion, body.expectedVersion, err.message);
+        }
+      }
+      throw err;
+    }
+  }
+  async getSource(name) {
+    return this.request("GET", `/api/workflows/${name}/source`);
+  }
+  async bundle(data) {
+    return this.request("POST", "/api/workflows/bundle", data);
+  }
+  async pauseAll() {
+    return this.request("POST", "/api/workflows/pause-all");
+  }
+  async cancelRun(runId) {
+    return this.request("POST", `/api/workflows/runs/${runId}/cancel`);
+  }
+  async rollback(name, toVersion) {
+    return this.request("POST", `/api/workflows/${name}/rollback`, toVersion ? { toVersion } : {});
+  }
+  async streamRun(name, runId, onEvent, signal) {
+    const url = `${this.baseUrl}/api/workflows/${name}/runs/${runId}/stream`;
+    const headers = {
+      Accept: "text/event-stream",
+      "x-sl-origin": this.origin
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    const res = await fetch(url, { headers, signal });
+    if (!res.ok || !res.body) {
+      throw new ApiError(res.status, `Failed to open workflow run stream (HTTP ${res.status})`);
+    }
+    const reader = res.body.pipeThrough(new TextDecoderStream).getReader();
+    let buffer = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done)
+        break;
+      buffer += value;
+      let sep = buffer.indexOf(`
+
+`);
+      while (sep !== -1) {
+        const chunk = buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+        const parsed = parseSseChunk(chunk);
+        if (parsed) {
+          onEvent(parsed);
+          if (parsed.type === "done" || parsed.type === "timeout") {
+            await reader.cancel().catch(() => {
+              return;
+            });
+            return;
+          }
+        }
+        sep = buffer.indexOf(`
+
+`);
+      }
+    }
   }
   async list() {
     return this.request("GET", "/api/workflows");
@@ -396,21 +450,15 @@ class Workflows extends BaseClient {
 
 // src/client.ts
 class SecondLayer extends BaseClient {
-  streams;
   subgraphs;
   marketplace;
   workflows;
   constructor(options = {}) {
     super(options);
-    this.streams = new Streams(options);
     this.subgraphs = new Subgraphs(options);
     this.marketplace = new Marketplace(options);
     this.workflows = new Workflows(options);
   }
-  async getQueueStats() {
-    const status = await this.request("GET", "/status");
-    return status.queue;
-  }
 }
 
 // src/subgraphs/get-subgraph.ts
@@ -431,13 +479,12 @@ function verifyWebhookSignature(rawBody, signatureHeader, secret, toleranceSecon
 export {
   verifyWebhookSignature,
   getSubgraph,
-  Workflows,
+  VersionConflictError,
   Subgraphs,
-  Streams,
   SecondLayer,
   Marketplace,
   ApiError
 };
 
-//# debugId=078A8B332D40B93464756E2164756E21
+//# debugId=E50F894A60802FF364756E2164756E21
 //# sourceMappingURL=index.js.map