@secondlayer/cli 1.10.0 → 1.11.0

package/dist/cli.js

@@ -2444,44 +2444,198 @@ var init_config = __esm(() => {
   };
 });
 
-// src/lib/docker.ts
-async function isDockerAvailable() {
+// src/lib/api-client.ts
+var exports_api_client = {};
+__export(exports_api_client, {
+  updateStreamByName: () => updateStreamByName,
+  updateStream: () => updateStream,
+  updateAccountProfile: () => updateAccountProfile,
+  unpublishSubgraphApi: () => unpublishSubgraphApi,
+  stopSubgraphApi: () => stopSubgraphApi,
+  rotateSecret: () => rotateSecret,
+  resumeAllStreams: () => resumeAllStreams,
+  resolveStreamId: () => resolveStreamId,
+  reindexSubgraphApi: () => reindexSubgraphApi,
+  querySubgraphTableCount: () => querySubgraphTableCount,
+  querySubgraphTable: () => querySubgraphTable,
+  publishSubgraphApi: () => publishSubgraphApi,
+  pauseAllStreams: () => pauseAllStreams,
+  listSubgraphsApi: () => listSubgraphsApi,
+  listStreams: () => listStreams,
+  handleApiError: () => handleApiError,
+  getSubgraphGaps: () => getSubgraphGaps,
+  getSubgraphApi: () => getSubgraphApi,
+  getStream: () => getStream,
+  getQueueStats: () => getQueueStats,
+  getMarketplaceSubgraph: () => getMarketplaceSubgraph,
+  getAccountProfile: () => getAccountProfile,
+  forkMarketplaceSubgraph: () => forkMarketplaceSubgraph,
+  enableStream: () => enableStream,
+  disableStream: () => disableStream,
+  deploySubgraphApi: () => deploySubgraphApi,
+  deleteSubgraphApi: () => deleteSubgraphApi,
+  deleteStream: () => deleteStream,
+  createStream: () => createStream,
+  browseMarketplace: () => browseMarketplace,
+  backfillSubgraphApi: () => backfillSubgraphApi,
+  authHeaders: () => authHeaders,
+  assertOk: () => assertOk,
+  ApiError: () => ApiError
+});
+import { SecondLayer } from "@secondlayer/sdk";
+import { ApiError } from "@secondlayer/sdk";
+async function assertOk(res) {
+  if (res.ok)
+    return;
+  const body = await res.text();
   try {
-    const result = await Bun.$`docker info`.quiet().nothrow();
-    return result.exitCode === 0;
-  } catch {
-    return false;
+    const parsed = JSON.parse(body);
+    if (typeof parsed.error === "string" && parsed.error)
+      throw new Error(parsed.error);
+  } catch (e) {
+    if (e instanceof Error && e.message !== body)
+      throw e;
   }
+  throw new Error(`HTTP ${res.status}`);
 }
-async function requireDocker() {
-  const whichResult = await Bun.$`which docker`.quiet().nothrow();
-  if (whichResult.exitCode !== 0) {
-    throw new DockerNotAvailableError(`Docker is not installed.
-
-` + `Install Docker:
-` + `  macOS:  brew install --cask docker
-` + `          or download from https://docker.com/products/docker-desktop
-` + `  Linux:  curl -fsSL https://get.docker.com | sh
-`);
-  }
-  const available = await isDockerAvailable();
-  if (!available) {
-    throw new DockerNotAvailableError(`Docker daemon is not running.
-
-` + `Start Docker:
-` + `  macOS:  Open Docker Desktop or OrbStack
-` + `  Linux:  sudo systemctl start docker
-`);
+function handleApiError(err, action) {
+  if (err instanceof ApiError && err.status === 401) {
+    console.error("Error: Authentication required. Run: sl auth login");
+    process.exit(1);
   }
+  console.error(`Error: Failed to ${action}: ${err}`);
+  process.exit(1);
 }
-var DockerNotAvailableError;
-var init_docker = __esm(() => {
-  DockerNotAvailableError = class DockerNotAvailableError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "DockerNotAvailableError";
-    }
-  };
+async function getClient() {
+  const config = await loadConfig();
+  const baseUrl = resolveApiUrl(config);
+  return new SecondLayer({ baseUrl, apiKey: config.apiKey });
+}
+function authHeaders(config) {
+  return SecondLayer.authHeaders(config.apiKey);
+}
+async function createStream(data) {
+  return (await getClient()).streams.create(data);
+}
+async function updateStream(id, data) {
+  return (await getClient()).streams.update(id, data);
+}
+async function updateStreamByName(name, data) {
+  return (await getClient()).streams.updateByName(name, data);
+}
+async function listStreams(params) {
+  return (await getClient()).streams.list(params);
+}
+async function resolveStreamId(partialId) {
+  return (await getClient()).streams.resolveStreamId(partialId);
+}
+async function getStream(id) {
+  return (await getClient()).streams.get(id);
+}
+async function deleteStream(id) {
+  return (await getClient()).streams.delete(id);
+}
+async function enableStream(id) {
+  return (await getClient()).streams.enable(id);
+}
+async function disableStream(id) {
+  return (await getClient()).streams.disable(id);
+}
+async function rotateSecret(id) {
+  return (await getClient()).streams.rotateSecret(id);
+}
+async function pauseAllStreams() {
+  return (await getClient()).streams.pauseAll();
+}
+async function resumeAllStreams() {
+  return (await getClient()).streams.resumeAll();
+}
+async function getQueueStats() {
+  return (await getClient()).getQueueStats();
+}
+async function listSubgraphsApi() {
+  return (await getClient()).subgraphs.list();
+}
+async function getSubgraphApi(name) {
+  return (await getClient()).subgraphs.get(name);
+}
+async function reindexSubgraphApi(name, options) {
+  return (await getClient()).subgraphs.reindex(name, options);
+}
+async function backfillSubgraphApi(name, options) {
+  return (await getClient()).subgraphs.backfill(name, options);
+}
+async function stopSubgraphApi(name) {
+  return (await getClient()).subgraphs.stop(name);
+}
+async function deleteSubgraphApi(name) {
+  return (await getClient()).subgraphs.delete(name);
+}
+async function deploySubgraphApi(data) {
+  return (await getClient()).subgraphs.deploy(data);
+}
+async function querySubgraphTable(name, table, params = {}) {
+  return (await getClient()).subgraphs.queryTable(name, table, params);
+}
+async function querySubgraphTableCount(name, table, params = {}) {
+  return (await getClient()).subgraphs.queryTableCount(name, table, params);
+}
+async function getSubgraphGaps(name, opts) {
+  return (await getClient()).subgraphs.gaps(name, opts);
+}
+async function getAccountProfile() {
+  const config = await loadConfig();
+  const baseUrl = resolveApiUrl(config);
+  const res = await fetch(`${baseUrl}/api/accounts/me`, {
+    headers: authHeaders(config)
+  });
+  await assertOk(res);
+  return res.json();
+}
+async function updateAccountProfile(data) {
+  const config = await loadConfig();
+  const baseUrl = resolveApiUrl(config);
+  const res = await fetch(`${baseUrl}/api/accounts/me`, {
+    method: "PATCH",
+    headers: authHeaders(config),
+    body: JSON.stringify(data)
+  });
+  await assertOk(res);
+  return res.json();
+}
+async function browseMarketplace(opts = {}) {
+  return (await getClient()).marketplace.browse(opts);
+}
+async function getMarketplaceSubgraph(name) {
+  return (await getClient()).marketplace.get(name);
+}
+async function forkMarketplaceSubgraph(name, newName) {
+  return (await getClient()).marketplace.fork(name, newName);
+}
+async function publishSubgraphApi(name, opts) {
+  const config = await loadConfig();
+  const baseUrl = resolveApiUrl(config);
+  const res = await fetch(`${baseUrl}/api/subgraphs/${name}/publish`, {
+    method: "POST",
+    headers: authHeaders(config),
+    body: JSON.stringify(opts ?? {})
+  });
+  await assertOk(res);
+  return res.json();
+}
+async function unpublishSubgraphApi(name) {
+  const config = await loadConfig();
+  const baseUrl = resolveApiUrl(config);
+  const res = await fetch(`${baseUrl}/api/subgraphs/${name}/unpublish`, {
+    method: "POST",
+    headers: authHeaders(config),
+    body: JSON.stringify({})
+  });
+  await assertOk(res);
+  return res.json();
+}
+var init_api_client = __esm(() => {
+  init_config();
 });
 
 // src/lib/output.ts
@@ -2556,6 +2710,46 @@ var init_output = __esm(() => {
   };
 });
 
+// src/lib/docker.ts
+async function isDockerAvailable() {
+  try {
+    const result = await Bun.$`docker info`.quiet().nothrow();
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function requireDocker() {
+  const whichResult = await Bun.$`which docker`.quiet().nothrow();
+  if (whichResult.exitCode !== 0) {
+    throw new DockerNotAvailableError(`Docker is not installed.
+
+` + `Install Docker:
+` + `  macOS:  brew install --cask docker
+` + `          or download from https://docker.com/products/docker-desktop
+` + `  Linux:  curl -fsSL https://get.docker.com | sh
+`);
+  }
+  const available = await isDockerAvailable();
+  if (!available) {
+    throw new DockerNotAvailableError(`Docker daemon is not running.
+
+` + `Start Docker:
+` + `  macOS:  Open Docker Desktop or OrbStack
+` + `  Linux:  sudo systemctl start docker
+`);
+  }
+}
+var DockerNotAvailableError;
+var init_docker = __esm(() => {
+  DockerNotAvailableError = class DockerNotAvailableError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "DockerNotAvailableError";
+    }
+  };
+});
+
 // ../../node_modules/postgres/src/query.js
 function cachedError(xs) {
   if (originCache.has(xs))
@@ -4546,142 +4740,6 @@ var init_src = __esm(() => {
   src_default = Postgres;
 });
 
-// src/lib/api-client.ts
-var exports_api_client = {};
-__export(exports_api_client, {
-  updateStreamByName: () => updateStreamByName,
-  updateStream: () => updateStream,
-  stopSubgraphApi: () => stopSubgraphApi,
-  rotateSecret: () => rotateSecret,
-  resumeAllStreams: () => resumeAllStreams,
-  resolveStreamId: () => resolveStreamId,
-  reindexSubgraphApi: () => reindexSubgraphApi,
-  querySubgraphTableCount: () => querySubgraphTableCount,
-  querySubgraphTable: () => querySubgraphTable,
-  pauseAllStreams: () => pauseAllStreams,
-  listSubgraphsApi: () => listSubgraphsApi,
-  listStreams: () => listStreams,
-  handleApiError: () => handleApiError,
-  getSubgraphGaps: () => getSubgraphGaps,
-  getSubgraphApi: () => getSubgraphApi,
-  getStream: () => getStream,
-  getQueueStats: () => getQueueStats,
-  enableStream: () => enableStream,
-  disableStream: () => disableStream,
-  deploySubgraphApi: () => deploySubgraphApi,
-  deleteSubgraphApi: () => deleteSubgraphApi,
-  deleteStream: () => deleteStream,
-  createStream: () => createStream,
-  backfillSubgraphApi: () => backfillSubgraphApi,
-  authHeaders: () => authHeaders,
-  assertOk: () => assertOk,
-  ApiError: () => ApiError
-});
-import { SecondLayer } from "@secondlayer/sdk";
-import { ApiError } from "@secondlayer/sdk";
-async function assertOk(res) {
-  if (res.ok)
-    return;
-  const body = await res.text();
-  try {
-    const parsed = JSON.parse(body);
-    if (typeof parsed.error === "string" && parsed.error)
-      throw new Error(parsed.error);
-  } catch (e) {
-    if (e instanceof Error && e.message !== body)
-      throw e;
-  }
-  throw new Error(`HTTP ${res.status}`);
-}
-function handleApiError(err, action) {
-  if (err instanceof ApiError && err.status === 401) {
-    console.error("Error: Authentication required. Run: sl auth login");
-    process.exit(1);
-  }
-  console.error(`Error: Failed to ${action}: ${err}`);
-  process.exit(1);
-}
-async function getClient() {
-  const config = await loadConfig();
-  const baseUrl = resolveApiUrl(config);
-  return new SecondLayer({ baseUrl, apiKey: config.apiKey });
-}
-function authHeaders(config) {
-  return SecondLayer.authHeaders(config.apiKey);
-}
-async function createStream(data) {
-  return (await getClient()).streams.create(data);
-}
-async function updateStream(id, data) {
-  return (await getClient()).streams.update(id, data);
-}
-async function updateStreamByName(name, data) {
-  return (await getClient()).streams.updateByName(name, data);
-}
-async function listStreams(params) {
-  return (await getClient()).streams.list(params);
-}
-async function resolveStreamId(partialId) {
-  return (await getClient()).streams.resolveStreamId(partialId);
-}
-async function getStream(id) {
-  return (await getClient()).streams.get(id);
-}
-async function deleteStream(id) {
-  return (await getClient()).streams.delete(id);
-}
-async function enableStream(id) {
-  return (await getClient()).streams.enable(id);
-}
-async function disableStream(id) {
-  return (await getClient()).streams.disable(id);
-}
-async function rotateSecret(id) {
-  return (await getClient()).streams.rotateSecret(id);
-}
-async function pauseAllStreams() {
-  return (await getClient()).streams.pauseAll();
-}
-async function resumeAllStreams() {
-  return (await getClient()).streams.resumeAll();
-}
-async function getQueueStats() {
-  return (await getClient()).getQueueStats();
-}
-async function listSubgraphsApi() {
-  return (await getClient()).subgraphs.list();
-}
-async function getSubgraphApi(name) {
-  return (await getClient()).subgraphs.get(name);
-}
-async function reindexSubgraphApi(name, options) {
-  return (await getClient()).subgraphs.reindex(name, options);
-}
-async function backfillSubgraphApi(name, options) {
-  return (await getClient()).subgraphs.backfill(name, options);
-}
-async function stopSubgraphApi(name) {
-  return (await getClient()).subgraphs.stop(name);
-}
-async function deleteSubgraphApi(name) {
-  return (await getClient()).subgraphs.delete(name);
-}
-async function deploySubgraphApi(data) {
-  return (await getClient()).subgraphs.deploy(data);
-}
-async function querySubgraphTable(name, table, params = {}) {
-  return (await getClient()).subgraphs.queryTable(name, table, params);
-}
-async function querySubgraphTableCount(name, table, params = {}) {
-  return (await getClient()).subgraphs.queryTableCount(name, table, params);
-}
-async function getSubgraphGaps(name, opts) {
-  return (await getClient()).subgraphs.gaps(name, opts);
-}
-var init_api_client = __esm(() => {
-  init_config();
-});
-
 // src/lib/dev-state.ts
 var exports_dev_state = {};
 __export(exports_dev_state, {
@@ -19089,42 +19147,42 @@ var require_queue = __commonJS((exports, module) => {
     queue.drained = drained;
     return queue;
     function push(value) {
-      var p = new Promise(function(resolve7, reject) {
+      var p = new Promise(function(resolve8, reject) {
         pushCb(value, function(err, result) {
           if (err) {
             reject(err);
             return;
           }
-          resolve7(result);
+          resolve8(result);
         });
       });
       p.catch(noop5);
       return p;
     }
     function unshift(value) {
-      var p = new Promise(function(resolve7, reject) {
+      var p = new Promise(function(resolve8, reject) {
         unshiftCb(value, function(err, result) {
           if (err) {
             reject(err);
             return;
           }
-          resolve7(result);
+          resolve8(result);
         });
       });
       p.catch(noop5);
       return p;
     }
     function drained() {
-      var p = new Promise(function(resolve7) {
+      var p = new Promise(function(resolve8) {
         process.nextTick(function() {
           if (queue.idle()) {
-            resolve7();
+            resolve8();
           } else {
             var previousDrain = queue.drain;
             queue.drain = function() {
               if (typeof previousDrain === "function")
                 previousDrain();
-              resolve7();
+              resolve8();
               queue.drain = previousDrain;
             };
           }
@@ -19585,9 +19643,9 @@ var require_stream3 = __commonJS((exports) => {
       });
     }
     _getStat(filepath) {
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve8, reject) => {
         this._stat(filepath, this._fsStatSettings, (error2, stats) => {
-          return error2 === null ? resolve7(stats) : reject(error2);
+          return error2 === null ? resolve8(stats) : reject(error2);
         });
       });
     }
@@ -19609,10 +19667,10 @@ var require_async5 = __commonJS((exports) => {
       this._readerStream = new stream_1.default(this._settings);
     }
     dynamic(root, options2) {
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve8, reject) => {
         this._walkAsync(root, options2, (error2, entries2) => {
           if (error2 === null) {
-            resolve7(entries2);
+            resolve8(entries2);
           } else {
             reject(error2);
           }
@@ -19622,10 +19680,10 @@ var require_async5 = __commonJS((exports) => {
     async static(patterns, options2) {
       const entries2 = [];
       const stream2 = this._readerStream.static(patterns, options2);
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve8, reject) => {
         stream2.once("error", reject);
         stream2.on("data", (entry) => entries2.push(entry));
-        stream2.once("end", () => resolve7(entries2));
+        stream2.once("end", () => resolve8(entries2));
       });
     }
   }
@@ -20266,7 +20324,7 @@ import { promises as fs3 } from "fs";
 import path from "path";
 import { isValidAddress as _validateStacksAddress } from "@secondlayer/stacks";
 import { getErrorMessage } from "@secondlayer/shared";
-import { toCamelCase as toCamelCase2 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
 
 class PluginManager {
   plugins = [];
@@ -20490,7 +20548,7 @@ ${JSON.stringify(content, null, 2)}`;
   }
   createUtils() {
     return {
-      toCamelCase: toCamelCase2,
+      toCamelCase: toCamelCase3,
       toKebabCase: (str) => {
         return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
       },
@@ -20541,7 +20599,7 @@ import {
   isAbiStringAscii as isAbiStringAscii2,
   isAbiStringUtf8 as isAbiStringUtf82,
   isAbiTuple,
-  toCamelCase as toCamelCase3
+  toCamelCase as toCamelCase4
 } from "@secondlayer/stacks/clarity";
 function generateClarityConversion(argName, argType) {
   const type = argType.type;
@@ -20632,7 +20690,7 @@ function generateClarityConversion(argName, argType) {
     const requiredFields = type.tuple.map((f) => f.name);
     const fieldNames = JSON.stringify(requiredFields);
     const fields = type.tuple.map((field) => {
-      const camelFieldName = toCamelCase3(field.name);
+      const camelFieldName = toCamelCase4(field.name);
       const fieldConversion = generateClarityConversion(`tupleValue.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -20681,7 +20739,7 @@ import {
   isAbiStringAscii as isAbiStringAscii3,
   isAbiStringUtf8 as isAbiStringUtf83,
   isAbiTuple as isAbiTuple2,
-  toCamelCase as toCamelCase4
+  toCamelCase as toCamelCase5
 } from "@secondlayer/stacks/clarity";
 function clarityTypeToTS(type) {
   if (typeof type === "string") {
@@ -20733,7 +20791,7 @@ function clarityTypeToTS(type) {
     return `${innerType}[]`;
   }
   if (isAbiTuple2(type)) {
-    const fields = type.tuple.map((field) => `${toCamelCase4(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
+    const fields = type.tuple.map((field) => `${toCamelCase5(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
     return `{ ${fields} }`;
   }
   if (isAbiResponse2(type)) {
@@ -20751,12 +20809,12 @@ var init_type_mapping = () => {};
 // src/utils/generator-helpers.ts
 import {
   isAbiTuple as isAbiTuple3,
-  toCamelCase as toCamelCase5
+  toCamelCase as toCamelCase6
 } from "@secondlayer/stacks/clarity";
 function generateMapKeyConversion(keyType) {
   if (isAbiTuple3(keyType)) {
     const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase5(field.name);
+      const camelFieldName = toCamelCase6(field.name);
       const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -20771,7 +20829,7 @@ var init_generator_helpers = __esm(() => {
 
 // src/generators/contract.ts
 import {
-  toCamelCase as toCamelCase6
+  toCamelCase as toCamelCase7
 } from "@secondlayer/stacks/clarity";
 function generateNetworkUtils() {
   return `/**
@@ -20863,7 +20921,7 @@ function generateAbiConstant(name, abi) {
   return `export const ${name}Abi = ${abiJson} as const`;
 }
 function generateMethod(func, address, contractName) {
-  const methodName = toCamelCase6(func.name);
+  const methodName = toCamelCase7(func.name);
   if (func.args.length === 0) {
     return `${methodName}() {
     return {
@@ -20876,7 +20934,7 @@ function generateMethod(func, address, contractName) {
   }
   if (func.args.length === 1) {
     const originalArgName = func.args[0].name;
-    const argName = toCamelCase6(originalArgName);
+    const argName = toCamelCase7(originalArgName);
     const argType = getTypeForArg(func.args[0]);
     const clarityConversion = generateClarityConversion(argName, func.args[0]);
     return `${methodName}(...args: [{ ${argName}: ${argType} }] | [${argType}]) {
@@ -20892,17 +20950,17 @@ function generateMethod(func, address, contractName) {
     }
   }`;
   }
-  const argsList = func.args.map((arg) => toCamelCase6(arg.name)).join(", ");
+  const argsList = func.args.map((arg) => toCamelCase7(arg.name)).join(", ");
   const argsTypes = func.args.map((arg) => {
-    const camelName = toCamelCase6(arg.name);
+    const camelName = toCamelCase7(arg.name);
     return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   const argsArray = func.args.map((arg) => {
-    const argName = toCamelCase6(arg.name);
+    const argName = toCamelCase7(arg.name);
     return generateClarityConversion(argName, arg);
   }).join(", ");
   const objectAccess = func.args.map((arg) => {
-    const camelName = toCamelCase6(arg.name);
+    const camelName = toCamelCase7(arg.name);
     return `args[0].${camelName}`;
   }).join(", ");
   const positionTypes = func.args.map((arg) => getTypeForArg(arg)).join(", ");
@@ -20924,7 +20982,7 @@ function generateMapsObject(maps, address, contractName) {
     return "";
   }
   const mapMethods = maps.map((map) => {
-    const methodName = toCamelCase6(map.name);
+    const methodName = toCamelCase7(map.name);
     const keyType = getTypeForArg({ type: map.key });
     const valueType = getTypeForArg({ type: map.value });
     const keyConversion = generateMapKeyConversion(map.key);
@@ -20985,7 +21043,7 @@ function generateVarsObject(variables, address, contractName) {
     return "";
   }
   const varMethods = dataVars.map((variable) => {
-    const methodName = toCamelCase6(variable.name);
+    const methodName = toCamelCase7(variable.name);
     const valueType = getTypeForArg({ type: variable.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -21030,7 +21088,7 @@ function generateConstantsObject(variables, address, contractName) {
     return "";
   }
   const constMethods = constants.map((constant) => {
-    const methodName = toCamelCase6(constant.name);
+    const methodName = toCamelCase7(constant.name);
     const valueType = getTypeForArg({ type: constant.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -22090,11 +22148,11 @@ var init_commands = __esm(() => {
 });
 
 // ../../node_modules/@antfu/ni/dist/shared/ni.B5qNAuoI.mjs
-import path3, { join as join7, dirname as dirname6, resolve as resolve7 } from "node:path";
+import path3, { join as join7, dirname as dirname6, resolve as resolve8 } from "node:path";
 import process$1 from "node:process";
 import require$$0 from "readline";
 import require$$2 from "events";
-import fs5, { promises, existsSync as existsSync2 } from "node:fs";
+import fs5, { promises, existsSync as existsSync3 } from "node:fs";
 import require$$0$1 from "os";
 import require$$1 from "tty";
 import os4 from "node:os";
@@ -26239,12 +26297,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve8, reject) {
+      return new Promise(function(resolve9, reject) {
         isexe(path4, options3 || {}, function(er, is2) {
           if (er) {
             reject(er);
           } else {
-            resolve8(is2);
+            resolve9(is2);
           }
         });
       });
@@ -26306,27 +26364,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve8, reject) => {
+    const step = (i2) => new Promise((resolve9, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve8(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve9(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path4.join(pathPart, cmd);
       const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve8(subStep(p2, i2, 0));
+      resolve9(subStep(p2, i2, 0));
     });
-    const subStep = (p2, i2, ii) => new Promise((resolve8, reject) => {
+    const subStep = (p2, i2, ii) => new Promise((resolve9, reject) => {
       if (ii === pathExt.length)
-        return resolve8(step(i2 + 1));
+        return resolve9(step(i2 + 1));
       const ext = pathExt[ii];
       isexe(p2 + ext, { pathExt: pathExtExe }, (er, is2) => {
         if (!er && is2) {
           if (opt.all)
             found.push(p2 + ext);
           else
-            return resolve8(p2 + ext);
+            return resolve9(p2 + ext);
         }
-        return resolve8(subStep(p2, i2, ii + 1));
+        return resolve9(subStep(p2, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -27264,8 +27322,8 @@ var init_validation = __esm(() => {
 // ../../node_modules/execa/lib/utils/deferred.js
 var createDeferred = () => {
   const methods = {};
-  const promise = new Promise((resolve8, reject) => {
-    Object.assign(methods, { resolve: resolve8, reject });
+  const promise = new Promise((resolve9, reject) => {
+    Object.assign(methods, { resolve: resolve9, reject });
   });
   return Object.assign(promise, methods);
 };
@@ -31608,10 +31666,10 @@ var initializeConcurrentStreams = () => ({
   const promises2 = weakMap.get(stream2);
   const promise = createDeferred();
   promises2.push(promise);
-  const resolve8 = promise.resolve.bind(promise);
-  return { resolve: resolve8, promises: promises2 };
-}, waitForConcurrentStreams = async ({ resolve: resolve8, promises: promises2 }, subprocess) => {
-  resolve8();
+  const resolve9 = promise.resolve.bind(promise);
+  return { resolve: resolve9, promises: promises2 };
+}, waitForConcurrentStreams = async ({ resolve: resolve9, promises: promises2 }, subprocess) => {
+  resolve9();
   const [isSubprocessExit] = await Promise.race([
     Promise.allSettled([true, subprocess]),
     Promise.all([false, ...promises2])
@@ -32314,7 +32372,7 @@ __export(exports_generate, {
 });
 import path10 from "path";
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { toCamelCase as toCamelCase7 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase8 } from "@secondlayer/stacks/clarity";
 function isContractAddress(input4) {
   const contractIdPattern = /^(SP|ST|SM|SN)[A-Z0-9]{38,}\.[a-zA-Z][a-zA-Z0-9-]*$/;
   return contractIdPattern.test(input4);
@@ -32375,7 +32433,7 @@ async function buildConfigFromInputs(parsedInputs, outPath, apiKey, defaultAddre
       const apiClient = new StacksApiClient(network, apiKey);
       const contractInfo = await apiClient.getContractInfo(contractId);
       const abi = parseApiResponse(contractInfo);
-      const name = toCamelCase7(contractName);
+      const name = toCamelCase8(contractName);
       contracts.push({
         name,
         address: contractId,
@@ -32620,7 +32678,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "1.10.0",
+  version: "1.11.0",
   description: "CLI for streams, subgraphs, and real-time blockchain indexing on Stacks",
   type: "module",
   bin: {
@@ -32661,10 +32719,11 @@ var package_default = {
   license: "MIT",
   dependencies: {
     "@inquirer/prompts": "^8.2.0",
-    "@secondlayer/sdk": "^0.9.0",
-    "@secondlayer/shared": "^0.10.0",
+    "@secondlayer/sdk": "^0.10.0",
+    "@secondlayer/shared": "^0.10.1",
     "@secondlayer/stacks": "^0.2.2",
-    "@secondlayer/subgraphs": "^0.8.0",
+    "@secondlayer/subgraphs": "^0.9.0",
+    "@secondlayer/workflows": "^0.0.1",
     "@biomejs/js-api": "^0.7.0",
     "@biomejs/wasm-nodejs": "^1.9.0",
     esbuild: "^0.19.0",
@@ -32685,6 +32744,52 @@ var package_default = {
   }
 };
 
+// src/commands/account.ts
+init_api_client();
+init_output();
+function registerAccountCommand(program2) {
+  const account = program2.command("account").description("Manage your account profile");
+  account.command("profile").description("View or update your public profile").option("--name <name>", "Set display name").option("--bio <bio>", "Set bio").option("--slug <slug>", "Set public URL slug").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const hasUpdates = options.name || options.bio || options.slug;
+      if (hasUpdates) {
+        const data = {};
+        if (options.name)
+          data.display_name = options.name;
+        if (options.bio)
+          data.bio = options.bio;
+        if (options.slug)
+          data.slug = options.slug;
+        const updated = await updateAccountProfile(data);
+        if (options.json) {
+          console.log(JSON.stringify(updated, null, 2));
+          return;
+        }
+        success("Profile updated");
+        console.log(formatKeyValue([
+          ["Display Name", updated.displayName ?? dim("—")],
+          ["Bio", updated.bio ?? dim("—")],
+          ["Slug", updated.slug ?? dim("—")]
+        ]));
+        return;
+      }
+      const profile = await getAccountProfile();
+      if (options.json) {
+        console.log(JSON.stringify(profile, null, 2));
+        return;
+      }
+      console.log(formatKeyValue([
+        ["Email", profile.email],
+        ["Plan", profile.plan],
+        ["Display Name", profile.displayName ?? dim("—")],
+        ["Bio", profile.bio ?? dim("—")],
+        ["Slug", profile.slug ?? dim("—")]
+      ]));
+    } catch (err) {
+      handleApiError(err, "manage profile");
+    }
+  });
+}
 // src/commands/config.ts
 init_config();
 
@@ -35226,6 +35331,9 @@ function mapType(abiType, nullable) {
 }
 
 // src/generators/subgraph-scaffold.ts
+function toCamelCase(str) {
+  return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
 async function generateSubgraphScaffold(input2) {
   const { contractId, functions } = input2;
   const contractParts = contractId.split(".");
@@ -35235,6 +35343,12 @@ async function generateSubgraphScaffold(input2) {
   if (publicFunctions.length === 0) {
     throw new Error(`No public functions found in ${contractId}`);
   }
+  const sourceEntries = publicFunctions.map((fn) => {
+    const sourceName = toCamelCase(fn.name);
+    return `    ${sourceName}: { type: 'contract_call', contractId: '${contractId}', functionName: '${fn.name}' }`;
+  });
+  const sourcesBlock = sourceEntries.join(`,
+`);
   const tables = publicFunctions.map((fn) => {
     const columns = fn.args.map((arg) => {
       const mapped = clarityTypeToSubgraphColumn(arg.type);
@@ -35251,14 +35365,15 @@ ${columns || "        _placeholder: { type: 'text' }"}
   });
   const schemaBlock = tables.join(`,
 `);
-  const handlerKeys = publicFunctions.map((fn) => {
-    return `    '${contractId}::${fn.name}': async (event, ctx) => {
+  const handlerEntries = publicFunctions.map((fn) => {
+    const sourceName = toCamelCase(fn.name);
+    return `    ${sourceName}: async (event, ctx) => {
       // TODO: implement ${fn.name} handler
       // event.args contains the function arguments
       // ctx.insert('${fn.name.replace(/-/g, "_")}', { ... })
     }`;
   });
-  const handlersBlock = handlerKeys.join(`,
+  const handlersBlock = handlerEntries.join(`,
 
 `);
   const code = `
@@ -35266,7 +35381,9 @@ import { defineSubgraph } from '@secondlayer/subgraphs';
 
 export default defineSubgraph({
   name: '${subgraphName}',
-  sources: [{ contract: '${contractId}' }],
+  sources: {
+${sourcesBlock}
+  },
   schema: {
 ${schemaBlock}
   },
@@ -35279,12 +35396,12 @@ ${handlersBlock}
 }
 
 // src/utils/case-conversion.ts
-import { toCamelCase } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase2 } from "@secondlayer/stacks/clarity";
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function toPascalCase(str) {
-  return capitalize(toCamelCase(str));
+  return capitalize(toCamelCase2(str));
 }
 
 // src/generators/subgraphs.ts
@@ -35378,15 +35495,19 @@ export default defineSubgraph({
   description: "TODO: describe what this subgraph tracks",
 
   // Sources define what blockchain data this subgraph processes.
-  // Each source filters transactions/events by contract, type, function, or event.
-  // Examples:
-  //   { contract: "SP000...::my-contract" }              — all txs to a contract
-  //   { contract: "SP000...::my-contract", event: "transfer" } — specific event
-  //   { type: "stx_transfer", minAmount: 1000000n }      — STX transfers >= 1 STX
-  //   { contract: "*.pox-*" }                             — wildcard contract match
-  sources: [
-    { contract: "SP000000000000000000002Q6VF78.pox-4" },
-  ],
+  // Each source is named — the name becomes the handler key.
+  //
+  // Filter types:
+  //   { type: "ft_transfer", assetIdentifier: "SP...token::token-name" }
+  //   { type: "ft_mint", assetIdentifier: "SP...token::token-name" }
+  //   { type: "contract_call", contractId: "SP...contract", functionName: "swap" }
+  //   { type: "contract_deploy" }
+  //   { type: "print_event", contractId: "SP...contract", topic: "my-event" }
+  //   { type: "stx_transfer", minAmount: 1000000n }
+  //   { type: "nft_transfer", assetIdentifier: "SP...nft::nft-name" }
+  sources: {
+    handler: { type: "contract_call", contractId: "SP000000000000000000002Q6VF78.pox-4" },
+  },
 
   // Schema defines the tables this subgraph creates.
   // Each table gets auto-columns: _id, _block_height, _tx_id, _created_at.
@@ -35398,20 +35519,18 @@ export default defineSubgraph({
         amount: { type: "uint" },
         memo: { type: "text", nullable: true },
       },
-      // Optional composite indexes
-      // indexes: [["sender", "amount"]],
     },
   },
 
-  // Handlers process matched events and write to your tables via the context.
-  // Keys match source patterns (use sourceKey format), or "*" as catch-all.
-  // Context methods: ctx.insert(), ctx.update(), ctx.delete()
+  // Handlers process matched events. Keys must match source names.
+  // Context: ctx.insert(), ctx.update(), ctx.upsert(), ctx.patch(),
+  //          ctx.patchOrInsert(), ctx.findOne(), ctx.findMany()
   handlers: {
-    "*": async (event, ctx) => {
-      await ctx.insert("data", {
-        sender: event.sender ?? event.tx?.sender,
+    handler: (event, ctx) => {
+      ctx.insert("data", {
+        sender: ctx.tx.sender,
         amount: event.amount ?? 0,
-        memo: event.memo ?? null,
+        memo: null,
       });
     },
   },
@@ -35520,12 +35639,11 @@ Stopped watching.`);
           write: false
         });
         const handlerCode = new TextDecoder().decode(buildResult.outputFiles[0].contents);
-        const { sourceKey } = await import("@secondlayer/subgraphs");
         const result = await deploySubgraphApi({
           name: def.name,
           version: def.version,
           description: def.description,
-          sources: def.sources.map(sourceKey),
+          sources: def.sources,
           schema: def.schema,
           handlerCode,
           reindex: options2.reindex
@@ -35781,6 +35899,37 @@ ${rows.length} row(s)`));
       handleApiError(err, "delete subgraph");
     }
   });
+  subgraphs.command("publish <name>").description("Publish a subgraph to the marketplace").option("--tags <tags>", "Tags (comma-separated, max 5)").option("--description <desc>", "Public description (max 500 chars)").option("--json", "Output as JSON").action(async (name, options2) => {
+    try {
+      const opts = {};
+      if (options2.tags) {
+        opts.tags = options2.tags.split(",").map((t) => t.trim());
+      }
+      if (options2.description) {
+        opts.description = options2.description;
+      }
+      const result = await publishSubgraphApi(name, opts);
+      if (options2.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      success(result.message);
+    } catch (err) {
+      handleApiError(err, "publish subgraph");
+    }
+  });
+  subgraphs.command("unpublish <name>").description("Remove a subgraph from the marketplace").option("--json", "Output as JSON").action(async (name, options2) => {
+    try {
+      const result = await unpublishSubgraphApi(name);
+      if (options2.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      success(result.message);
+    } catch (err) {
+      handleApiError(err, "unpublish subgraph");
+    }
+  });
   subgraphs.command("scaffold <contractAddress>").description("Scaffold a defineSubgraph() file from a contract ABI").option("-o, --output <path>", "Output file path (required)").option("--api-key <key>", "Hiro API key").action(async (contractAddress, options2) => {
     try {
       if (!options2.output) {
@@ -36951,6 +37100,87 @@ function formatDeliverySummary2(jsonStr) {
     return null;
   }
 }
+// src/commands/marketplace.ts
+init_api_client();
+init_output();
+function registerMarketplaceCommand(program2) {
+  const marketplace = program2.command("marketplace").alias("mp").description("Browse the public subgraph marketplace");
+  marketplace.command("browse").description("List public subgraphs").option("--tags <tags>", "Filter by tags (comma-separated)").option("--search <query>", "Search by name or description").option("--sort <field>", "Sort by: recent, popular, name", "recent").option("--limit <n>", "Max results", "20").option("--json", "Output as JSON").action(async (options2) => {
+    try {
+      const result = await browseMarketplace({
+        tags: options2.tags ? options2.tags.split(",").map((t) => t.trim()) : undefined,
+        search: options2.search,
+        sort: options2.sort,
+        limit: Number.parseInt(options2.limit ?? "20", 10)
+      });
+      if (options2.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (result.data.length === 0) {
+        console.log(dim("No public subgraphs found"));
+        return;
+      }
+      const rows = result.data.map((s) => [
+        s.name,
+        s.creator?.displayName ?? s.creator?.slug ?? dim("—"),
+        (s.tags ?? []).join(", ") || dim("—"),
+        s.status
+      ]);
+      console.log(formatTable(["Name", "Creator", "Tags", "Status"], rows));
+      console.log(dim(`
+${result.meta.total} subgraph(s) total`));
+    } catch (err) {
+      handleApiError(err, "browse marketplace");
+    }
+  });
+  marketplace.command("view <name>").description("View a public subgraph's details").option("--json", "Output as JSON").action(async (name, options2) => {
+    try {
+      const detail = await getMarketplaceSubgraph(name);
+      if (options2.json) {
+        console.log(JSON.stringify(detail, null, 2));
+        return;
+      }
+      console.log(formatKeyValue([
+        ["Name", detail.name],
+        ["Description", detail.description ?? dim("—")],
+        ["Creator", detail.creator?.displayName ?? detail.creator?.slug ?? dim("—")],
+        ["Status", detail.status],
+        ["Version", detail.version],
+        ["Tags", (detail.tags ?? []).join(", ") || dim("—")],
+        ["Tables", detail.tables?.join(", ") ?? dim("—")],
+        ["Start Block", String(detail.startBlock)],
+        ["Last Processed", String(detail.lastProcessedBlock)],
+        ["Queries (7d)", String(detail.usage?.totalQueries7d ?? 0)],
+        ["Queries (30d)", String(detail.usage?.totalQueries30d ?? 0)],
+        ["Created", detail.createdAt]
+      ]));
+      if (detail.tableSchemas) {
+        console.log(dim(`
+Endpoints:`));
+        for (const [table, schema] of Object.entries(detail.tableSchemas)) {
+          console.log(`  ${cyan(table)} — ${schema.rowCount} rows — ${schema.endpoint}`);
+        }
+      }
+    } catch (err) {
+      handleApiError(err, "view subgraph");
+    }
+  });
+  marketplace.command("fork <name>").description("Fork a public subgraph into your account").option("--name <newName>", "Name for the forked subgraph").option("--json", "Output as JSON").action(async (name, options2) => {
+    try {
+      const result = await forkMarketplaceSubgraph(name, options2.name);
+      if (options2.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      success(`Forked ${result.forkedFrom} as ${result.name}`);
+      console.log(dim(`Subgraph ID: ${result.subgraphId}`));
+      console.log(dim("Indexing will start automatically from the source's start block."));
+    } catch (err) {
+      handleApiError(err, "fork subgraph");
+    }
+  });
+}
 // src/commands/whoami.ts
 init_api_client();
 init_config();
@@ -36987,9 +37217,180 @@ function registerWhoamiCommand(program2) {
     }
   });
 }
+// src/commands/workflows.ts
+init_output();
+import { existsSync as existsSync2 } from "node:fs";
+import { resolve as resolve7 } from "node:path";
+import { SecondLayer as SecondLayer2 } from "@secondlayer/sdk";
+function getClient2() {
+  const apiKey = process.env.SECONDLAYER_API_KEY;
+  if (!apiKey) {
+    error("SECONDLAYER_API_KEY required. Run: sl auth login");
+    process.exit(1);
+  }
+  return new SecondLayer2({ apiKey });
+}
+function registerWorkflowsCommand(program2) {
+  const workflows = program2.command("workflows").description("Manage workflows");
+  workflows.command("deploy <file>").description("Validate and deploy a workflow definition file").action(async (file) => {
+    try {
+      const absPath = resolve7(file);
+      if (!existsSync2(absPath)) {
+        error(`File not found: ${absPath}`);
+        process.exit(1);
+      }
+      info(`Loading workflow from ${absPath}`);
+      const mod = await import(absPath);
+      const def = mod.default ?? mod;
+      const { validateWorkflowDefinition } = await import("@secondlayer/workflows/validate");
+      const result = validateWorkflowDefinition(def);
+      success(`Workflow "${result.name}" is valid`);
+      info(`Trigger: ${result.trigger.type}`);
+      if (result.retries) {
+        info(`Retries: maxAttempts=${result.retries.maxAttempts ?? "default"}`);
+      }
+      if (result.timeout) {
+        info(`Timeout: ${result.timeout}ms`);
+      }
+    } catch (err) {
+      error(`Failed to validate workflow: ${err}`);
+      process.exit(1);
+    }
+  });
+  workflows.command("list").alias("ls").description("List all workflows").option("--json", "Output as JSON").action(async (options2) => {
+    try {
+      const { workflows: items } = await getClient2().workflows.list();
+      if (options2.json) {
+        console.log(JSON.stringify(items, null, 2));
+        return;
+      }
+      if (items.length === 0) {
+        console.log("No workflows deployed");
+        return;
+      }
+      const rows = items.map((w) => {
+        const statusColor = w.status === "active" ? green : yellow;
+        return [
+          w.name,
+          statusColor(w.status),
+          w.triggerType,
+          w.createdAt
+        ];
+      });
+      console.log(formatTable(["Name", "Status", "Trigger", "Created"], rows));
+      console.log(dim(`
+${items.length} workflow(s) total`));
+    } catch (err) {
+      error(`Failed to list workflows: ${err}`);
+      process.exit(1);
+    }
+  });
+  workflows.command("get <name>").description("Get workflow details").option("--json", "Output as JSON").action(async (name, options2) => {
+    try {
+      const detail = await getClient2().workflows.get(name);
+      if (options2.json) {
+        console.log(JSON.stringify(detail, null, 2));
+        return;
+      }
+      console.log(formatKeyValue([
+        ["Name", detail.name],
+        ["Status", detail.status],
+        ["Trigger", detail.triggerType],
+        ["Total Runs", String(detail.totalRuns)],
+        ["Last Run", detail.lastRunAt ?? "never"],
+        ["Timeout", detail.timeout ? `${detail.timeout}ms` : "default"],
+        ["Created", detail.createdAt],
+        ["Updated", detail.updatedAt]
+      ]));
+    } catch (err) {
+      error(`Failed to get workflow: ${err}`);
+      process.exit(1);
+    }
+  });
+  workflows.command("trigger <name>").description("Trigger a workflow run").option("--input <json>", "Input JSON string").action(async (name, options2) => {
+    try {
+      const input4 = options2.input ? JSON.parse(options2.input) : undefined;
+      const result = await getClient2().workflows.trigger(name, input4);
+      success(`Triggered workflow "${name}"`);
+      info(`Run ID: ${result.runId}`);
+    } catch (err) {
+      error(`Failed to trigger workflow: ${err}`);
+      process.exit(1);
+    }
+  });
+  workflows.command("runs <name>").description("List runs for a workflow").option("--status <status>", "Filter by status").option("--limit <n>", "Max runs to return", "20").option("--json", "Output as JSON").action(async (name, options2) => {
+    try {
+      const { runs } = await getClient2().workflows.listRuns(name, {
+        status: options2.status,
+        limit: options2.limit ? Number.parseInt(options2.limit, 10) : undefined
+      });
+      if (options2.json) {
+        console.log(JSON.stringify(runs, null, 2));
+        return;
+      }
+      if (runs.length === 0) {
+        console.log("No runs found");
+        return;
+      }
+      const rows = runs.map((r) => {
+        const statusColor = r.status === "completed" ? green : r.status === "failed" ? (s) => `\x1B[31m${s}\x1B[0m` : yellow;
+        return [
+          r.id.slice(0, 8),
+          statusColor(r.status),
+          `${r.duration}ms`,
+          String(r.aiTokensUsed),
+          r.triggeredAt
+        ];
+      });
+      console.log(formatTable(["ID", "Status", "Duration", "AI Tokens", "Triggered"], rows));
+      console.log(dim(`
+${runs.length} run(s)`));
+    } catch (err) {
+      error(`Failed to list runs: ${err}`);
+      process.exit(1);
+    }
+  });
+  workflows.command("pause <name>").description("Pause a workflow").action(async (name) => {
+    try {
+      await getClient2().workflows.pause(name);
+      success(`Paused workflow "${name}"`);
+    } catch (err) {
+      error(`Failed to pause workflow: ${err}`);
+      process.exit(1);
+    }
+  });
+  workflows.command("resume <name>").description("Resume a paused workflow").action(async (name) => {
+    try {
+      await getClient2().workflows.resume(name);
+      success(`Resumed workflow "${name}"`);
+    } catch (err) {
+      error(`Failed to resume workflow: ${err}`);
+      process.exit(1);
+    }
+  });
+  workflows.command("delete <name>").description("Delete a workflow").option("-y, --yes", "Skip confirmation").action(async (name, options2) => {
+    try {
+      if (!options2.yes) {
+        const { confirm: confirm7 } = await import("@inquirer/prompts");
+        const ok = await confirm7({
+          message: `Delete workflow "${name}"? This cannot be undone.`
+        });
+        if (!ok) {
+          info("Cancelled");
+          return;
+        }
+      }
+      await getClient2().workflows.delete(name);
+      success(`Deleted workflow "${name}"`);
+    } catch (err) {
+      error(`Failed to delete workflow: ${err}`);
+      process.exit(1);
+    }
+  });
+}
 // src/cli.ts
 var { version } = package_default;
-program.name("secondlayer").alias("sl").description("SecondLayer CLI — streams, subgraphs, and real-time indexing for Stacks").version(version).option("--network <network>", "Override network (local, testnet, mainnet)");
+program.name("secondlayer").alias("sl").description("SecondLayer CLI — streams, subgraphs, workflows, and real-time indexing for Stacks").version(version).option("--network <network>", "Override network (local, testnet, mainnet)");
 program.hook("preAction", (thisCommand) => {
   const net3 = thisCommand.opts().network;
   if (net3)
@@ -37012,8 +37413,11 @@ program.command("init").description("Initialize a new secondlayer.config.ts file
 });
 registerStreamsCommand(program);
 registerSubgraphsCommand(program);
+registerWorkflowsCommand(program);
+registerMarketplaceCommand(program);
 registerStatusCommand(program);
 registerLocalCommand(program);
+registerAccountCommand(program);
 registerStackCommand(program);
 registerDbCommand(program);
 registerSyncCommand(program);
@@ -37025,5 +37429,5 @@ registerWhoamiCommand(program);
 registerReceiverCommand(program);
 program.parse();
 
-//# debugId=2406566DC849ADA464756E2164756E21
+//# debugId=48CCB0723E8C164C64756E2164756E21
 //# sourceMappingURL=cli.js.map