@secondlayer/sdk 6.16.0 → 6.17.0

package/dist/subgraphs/index.d.ts

@@ -156,6 +156,17 @@ interface CreateApiKeyResponse {
 	tier: string | null;
 	createdAt: string;
 }
+/** A key as seen by {@link ApiKeys.list} — metadata only, never the plaintext. */
+interface ApiKeySummary {
+	id: string;
+	prefix: string;
+	name: string | null;
+	status: "active" | "revoked";
+	product: string;
+	tier: string | null;
+	createdAt: string;
+	lastUsedAt: string | null;
+}
 declare class ApiKeys extends BaseClient {
 	constructor(options?: Partial<SecondLayerOptions>);
 	/**
@@ -164,6 +175,18 @@ declare class ApiKeys extends BaseClient {
 	* only once.
 	*/
 	create(params?: CreateApiKeyParams): Promise<CreateApiKeyResponse>;
+	/**
+	* List the account's keys (metadata only — no plaintext). Requires an
+	* account-level (owner) key or a dashboard session.
+	*/
+	list(): Promise<{
+		keys: ApiKeySummary[]
+	}>;
+	/** Revoke a key by id. Existing requests with that key stop working. */
+	revoke(id: string): Promise<{
+		revoked: true
+		id: string
+	}>;
 }
 /**
 * Typed client for the contract-discovery API (`GET /v1/contracts`).
@@ -284,13 +307,26 @@ type CursorDataset<P> = {
 	}) => AsyncIterable<DatasetRow>
 };
 declare class Datasets extends BaseClient {
+	private catalogPromise?;
 	constructor(options?: Partial<SecondLayerOptions>);
 	/** Dataset catalog + freshness (the discovery endpoint). */
 	listDatasets(): Promise<unknown>;
 	/**
+	* Generic read by slug for ANY catalog dataset — cursor or bespoke. Resolves
+	* the slug against the live `/v1/datasets` catalog (so datasets added
+	* server-side work with no SDK change), issues the GET, and normalizes the
+	* response into a uniform `{ rows, next_cursor, tip }` envelope. Single-object
+	* datasets (bns/resolve, network-health/summary) come back as 0-or-1 rows.
+	* Accepts both family (`sbtc-events`) and path (`sbtc/events`) slug forms.
+	* Prefer this over {@link query} unless you specifically need cursor-only
+	* semantics.
+	*/
+	get(slug: string, params?: Record<string, unknown>): Promise<CursorEnvelope>;
+	/**
 	* Generic cursor query by slug — used by the CLI. Params are passed through as
 	* REST query keys (snake_case), so callers can use the documented filter names
-	* directly. Throws for non-cursor (bespoke) datasets.
+	* directly. Throws for non-cursor (bespoke) datasets — use {@link get} for
+	* those (and for slugs added to the catalog after this SDK was built).
 	*/
 	query(slug: string, params?: Record<string, unknown>): Promise<CursorEnvelope>;
 	readonly stxTransfers: CursorDataset<StxTransfersParams>;
@@ -323,7 +359,15 @@ declare class Datasets extends BaseClient {
 	networkHealth(): Promise<{
 		summary: DatasetRow
 	}>;
-	private get;
+	private requestPath;
+	/** Resolve a slug → relative path + row key. Known cursor slugs take a
+	*  network-free fast path; anything else is matched against the live catalog
+	*  by family name or path tail. */
+	private resolveDataset;
+	/** Fetch + cache the catalog families. Caches the in-flight promise so
+	*  concurrent first-calls share one request; no TTL — agent sessions are
+	*  short-lived, and a new client picks up newly added datasets. */
+	private loadCatalog;
 	/** Map camelCase filter fields to snake_case query keys (dropping pagination
 	*  controls) and build the canonical query suffix. */
 	private paramsToQuery;
@@ -898,6 +942,76 @@ declare class Index extends BaseClient {
 	private getMempoolTx;
 	private walkMempool;
 }
+/**
+* Typed client for project management (`/api/projects/*`).
+*
+* Projects are the account-scoped containers for work. Every method requires an
+* account-level (owner) API key or a dashboard session — scoped read keys are
+* rejected. Team mutations (invite/remove/role) are intentionally not exposed
+* here; only the read view ({@link Projects.team}) is.
+*/
+interface Project {
+	id: string;
+	name: string;
+	slug: string;
+	network: string;
+	nodeRpc: string | null;
+	settings: Record<string, unknown> | null;
+	createdAt: string;
+	updatedAt: string;
+}
+interface ProjectTeamMember {
+	id: string;
+	role: string;
+	email: string;
+	displayName: string | null;
+	avatarUrl: string | null;
+	createdAt: string;
+}
+interface ProjectInvitation {
+	id: string;
+	email: string;
+	role: string;
+	expiresAt: string;
+	createdAt: string;
+}
+interface ProjectTeam {
+	members: ProjectTeamMember[];
+	invitations: ProjectInvitation[];
+}
+interface CreateProjectParams {
+	name: string;
+	slug?: string;
+	network?: string;
+	nodeRpc?: string;
+}
+interface UpdateProjectParams {
+	name?: string;
+	/** Rename the project's URL slug. */
+	slug?: string;
+	network?: string;
+	nodeRpc?: string;
+	settings?: Record<string, unknown>;
+}
+declare class Projects extends BaseClient {
+	constructor(options?: Partial<SecondLayerOptions>);
+	/** All projects owned by the account, newest-relevant first. */
+	list(): Promise<{
+		projects: Project[]
+	}>;
+	/** A single project by slug. */
+	get(slug: string): Promise<Project>;
+	/** Create a project. The creator is added as the project owner. */
+	create(params: CreateProjectParams): Promise<Project>;
+	/** Update a project's name, slug (rename), network, RPC, or settings. */
+	update(slug: string, patch: UpdateProjectParams): Promise<Project>;
+	/** Delete a project. The account's last remaining project cannot be deleted. */
+	delete(slug: string): Promise<{
+		ok: true
+	}>;
+	/** Team members and pending invitations for a project. */
+	team(slug: string): Promise<ProjectTeam>;
+}
 import { StreamsEventType } from "@secondlayer/shared";
 /** A Clarity value as Streams serves it: the canonical hex string, a typed
 *  object carrying that hex (`{ hex }`), or a decoded Clarity-JSON object.
@@ -1309,6 +1423,19 @@ interface ContextAccount {
 	email: string;
 	plan: string;
 }
+/** Compact project view for {@link ContextSnapshot}. */
+interface ContextProject {
+	name: string;
+	slug: string;
+	network: string;
+}
+/** Compact API-key view for {@link ContextSnapshot} — never the plaintext. */
+interface ContextApiKey {
+	prefix: string;
+	name: string | null;
+	status: string;
+	product: string;
+}
 interface ActiveSubgraphOperation {
 	subgraph: string;
 	operationId: string;
@@ -1330,6 +1457,10 @@ interface ContextSnapshot {
 		count: number
 		byStatus: Record<string, number>
 	} | null;
+	/** The account's projects (null when unreadable — e.g. a scoped key). */
+	projects: ContextProject[] | null;
+	/** The account's API keys, metadata only (null when unreadable). */
+	apiKeys: ContextApiKey[] | null;
 	/** In-flight reindex operations (bounded to subgraphs reporting `reindexing`). */
 	activeOperations: ActiveSubgraphOperation[] | null;
 }
@@ -1341,6 +1472,7 @@ declare class SecondLayer extends BaseClient {
 	readonly subgraphs: Subgraphs;
 	readonly subscriptions: Subscriptions;
 	readonly apiKeys: ApiKeys;
+	readonly projects: Projects;
 	constructor(options?: Partial<SecondLayerOptions>);
 	/**
 	* Assemble a {@link ContextSnapshot} — the same orientation an MCP agent reads

package/dist/subgraphs/index.js

@@ -395,6 +395,12 @@ class ApiKeys extends BaseClient {
       name: params.name
     });
   }
+  list() {
+    return this.request("GET", "/api/keys");
+  }
+  revoke(id) {
+    return this.request("DELETE", `/api/keys/${id}`);
+  }
 }
 
 // src/contracts/client.ts
@@ -441,20 +447,35 @@ var CURSOR_SLUGS = {
     rowKey: "events"
   }
 };
+function catalogPathTail(path) {
+  return path.replace(/^\/?v1\/datasets\//, "").replace(/^\/+/, "");
+}
 
 class Datasets extends BaseClient {
+  catalogPromise;
   constructor(options = {}) {
     super(options);
   }
   listDatasets() {
     return this.request("GET", "/v1/datasets");
   }
+  async get(slug, params = {}) {
+    const { path, rowKey } = await this.resolveDataset(slug);
+    const env = await this.requestPath(path, this.paramsToQuery(params));
+    const value = env[rowKey];
+    const rows = Array.isArray(value) ? value : value == null ? [] : [value];
+    return {
+      rows,
+      next_cursor: env.next_cursor ?? null,
+      tip: env.tip
+    };
+  }
   async query(slug, params = {}) {
     const d = CURSOR_SLUGS[slug];
     if (!d) {
       throw new Error(`unknown cursor dataset "${slug}" (use one of: ${Object.keys(CURSOR_SLUGS).join(", ")})`);
     }
-    const env = await this.get(d.path, this.paramsToQuery(params));
+    const env = await this.requestPath(d.path, this.paramsToQuery(params));
     return {
       rows: env[d.rowKey] ?? [],
       next_cursor: env.next_cursor ?? null,
@@ -471,7 +492,7 @@ class Datasets extends BaseClient {
   bnsNamespaceEvents = this.cursorDataset("bns/namespace-events", "events");
   bnsMarketplaceEvents = this.cursorDataset("bns/marketplace-events", "events");
   bnsNames(params = {}) {
-    return this.get("bns/names", buildQuery({
+    return this.requestPath("bns/names", buildQuery({
       namespace: params.namespace,
       owner: params.owner,
       limit: params.limit,
@@ -479,17 +500,40 @@ class Datasets extends BaseClient {
     }));
   }
   bnsNamespaces() {
-    return this.get("bns/namespaces", "");
+    return this.requestPath("bns/namespaces", "");
   }
   bnsResolve(fqn) {
-    return this.get("bns/resolve", buildQuery({ fqn }));
+    return this.requestPath("bns/resolve", buildQuery({ fqn }));
   }
   networkHealth() {
-    return this.get("network-health/summary", "");
+    return this.requestPath("network-health/summary", "");
   }
-  get(path, query) {
+  requestPath(path, query) {
     return this.request("GET", `/v1/datasets/${path}${query}`);
   }
+  async resolveDataset(slug) {
+    const cursor = CURSOR_SLUGS[slug];
+    if (cursor)
+      return { path: cursor.path, rowKey: cursor.rowKey };
+    const families = await this.loadCatalog();
+    const tail = catalogPathTail(slug);
+    const match = families.find((f) => f.family === slug || catalogPathTail(f.path) === tail);
+    if (!match) {
+      throw new Error(`unknown dataset "${slug}" (available: ${families.map((f) => f.family).join(", ")})`);
+    }
+    return { path: catalogPathTail(match.path), rowKey: match.row_key };
+  }
+  loadCatalog() {
+    this.catalogPromise ??= (async () => {
+      const raw = await this.listDatasets();
+      const families = raw.families;
+      if (!Array.isArray(families)) {
+        throw new Error("dataset catalog response missing families[]");
+      }
+      return families;
+    })();
+    return this.catalogPromise;
+  }
   paramsToQuery(params) {
     const mapped = {};
     for (const [k, v] of Object.entries(params)) {
@@ -501,7 +545,7 @@ class Datasets extends BaseClient {
   }
   cursorDataset(path, rowKey) {
     const list = async (params = {}) => {
-      const envelope = await this.get(path, this.paramsToQuery(params));
+      const envelope = await this.requestPath(path, this.paramsToQuery(params));
       return {
         rows: envelope[rowKey] ?? [],
         next_cursor: envelope.next_cursor ?? null,
@@ -944,6 +988,31 @@ class Index extends BaseClient {
   }
 }
 
+// src/projects/client.ts
+class Projects extends BaseClient {
+  constructor(options = {}) {
+    super(options);
+  }
+  list() {
+    return this.request("GET", "/api/projects");
+  }
+  get(slug) {
+    return this.request("GET", `/api/projects/${slug}`);
+  }
+  create(params) {
+    return this.request("POST", "/api/projects", params);
+  }
+  update(slug, patch) {
+    return this.request("PATCH", `/api/projects/${slug}`, patch);
+  }
+  delete(slug) {
+    return this.request("DELETE", `/api/projects/${slug}`);
+  }
+  team(slug) {
+    return this.request("GET", `/api/projects/${slug}/team`);
+  }
+}
+
 // src/streams/client.ts
 import { ed25519 as ed255192 } from "@secondlayer/shared";
 
@@ -1622,6 +1691,7 @@ class SecondLayer extends BaseClient {
   subgraphs;
   subscriptions;
   apiKeys;
+  projects;
   constructor(options = {}) {
     super(options);
     this.streams = createStreamsClient({
@@ -1635,15 +1705,26 @@ class SecondLayer extends BaseClient {
     this.subgraphs = new Subgraphs(options);
     this.subscriptions = new Subscriptions(options);
     this.apiKeys = new ApiKeys(options);
+    this.projects = new Projects(options);
   }
   async context() {
     const safe = (p) => p.then((v) => v).catch(() => null);
-    const [account, streamsTip, indexEnv, subgraphsRes, subscriptionsRes] = await Promise.all([
+    const [
+      account,
+      streamsTip,
+      indexEnv,
+      subgraphsRes,
+      subscriptionsRes,
+      projectsRes,
+      apiKeysRes
+    ] = await Promise.all([
       safe(this.request("GET", "/api/accounts/me")),
       safe(this.streams.tip()),
       safe(this.index.canonical.list({ limit: 1 })),
       safe(this.subgraphs.list()),
-      safe(this.subscriptions.list())
+      safe(this.subscriptions.list()),
+      safe(this.projects.list()),
+      safe(this.apiKeys.list())
     ]);
     const subgraphs = subgraphsRes?.data ?? null;
     let subscriptions = null;
@@ -1669,12 +1750,25 @@ class SecondLayer extends BaseClient {
       }));
       activeOperations = probed.filter((o) => o !== null);
     }
+    const projects = projectsRes ? projectsRes.projects.map((p) => ({
+      name: p.name,
+      slug: p.slug,
+      network: p.network
+    })) : null;
+    const apiKeys = apiKeysRes ? apiKeysRes.keys.map((k) => ({
+      prefix: k.prefix,
+      name: k.name,
+      status: k.status,
+      product: k.product
+    })) : null;
     return {
       account,
       streamsTip,
       indexTip: indexEnv?.tip ?? null,
       subgraphs,
       subscriptions,
+      projects,
+      apiKeys,
       activeOperations
     };
   }
@@ -1695,5 +1789,5 @@ export {
   Subgraphs
 };
 
-//# debugId=4CC7A5C19CBAC4F064756E2164756E21
+//# debugId=9A541BEB19FD0E7964756E2164756E21
 //# sourceMappingURL=index.js.map