@treeseed/sdk 0.6.26 → 0.6.28

package/dist/index.d.ts

@@ -22,6 +22,7 @@ export { resolveSdkRecordVersion } from './sdk-version.ts';
 export { normalizeAliasedRecord, preprocessAliasedRecord, resolveAliasedField, } from './field-aliases.ts';
 export { canonicalizeFrontmatter, normalizeFilterFields, normalizeMutationData, normalizeRecordToCanonicalShape, normalizeSortFields, readCanonicalFieldValue, resolveModelField, validateModelFieldAliases, } from './sdk-fields.ts';
 export { RemoteTemplateCatalogClient, parseTemplateCatalogResponse } from './template-catalog.ts';
+export { MarketClient, MarketApiError, DEFAULT_TREESEED_MARKET_BASE_URL, TREESEED_CATALOG_MARKET_API_BASE_URLS_ENV, TREESEED_CENTRAL_MARKET_API_BASE_URL_ENV, TREESEED_MARKET_API_BASE_URL_ENV, addMarketProfile, clearMarketSession, listIntegratedMarketCatalog, loadMarketRegistryState, removeMarketProfile, resolveCatalogMarketProfiles, resolveDefaultCentralMarketBaseUrl, resolveIntegratedCatalogArtifactDownload, resolveMarketProfile, resolveMarketSession, setActiveMarketProfile, setMarketSession, verifyArtifactBytes, writeMarketRegistryState, } from './market-client.ts';
 export { TREESEED_REMOTE_CONTRACT_HEADER, TREESEED_REMOTE_CONTRACT_VERSION, CloudflareQueuePullClient, CloudflareQueuePushClient, RemoteTreeseedClient, RemoteTreeseedAuthClient, RemoteTreeseedDispatchClient, RemoteTreeseedJobsClient, RemoteTreeseedRunnerClient, RemoteTreeseedSdkClient, RemoteTreeseedOperationsClient, } from './remote.ts';
 export { TRESEED_OPERATION_SPECS, findTreeseedOperation, listTreeseedOperationNames, } from './operations-registry.ts';
 export { TreeseedOperationsSdk } from './operations/runtime.ts';

package/dist/index.js

@@ -123,6 +123,28 @@ import {
   validateModelFieldAliases
 } from "./sdk-fields.js";
 import { RemoteTemplateCatalogClient, parseTemplateCatalogResponse } from "./template-catalog.js";
+import {
+  MarketClient,
+  MarketApiError,
+  DEFAULT_TREESEED_MARKET_BASE_URL,
+  TREESEED_CATALOG_MARKET_API_BASE_URLS_ENV,
+  TREESEED_CENTRAL_MARKET_API_BASE_URL_ENV,
+  TREESEED_MARKET_API_BASE_URL_ENV,
+  addMarketProfile,
+  clearMarketSession,
+  listIntegratedMarketCatalog,
+  loadMarketRegistryState,
+  removeMarketProfile,
+  resolveCatalogMarketProfiles,
+  resolveDefaultCentralMarketBaseUrl,
+  resolveIntegratedCatalogArtifactDownload,
+  resolveMarketProfile,
+  resolveMarketSession,
+  setActiveMarketProfile,
+  setMarketSession,
+  verifyArtifactBytes,
+  writeMarketRegistryState
+} from "./market-client.js";
 import {
   TREESEED_REMOTE_CONTRACT_HEADER,
   TREESEED_REMOTE_CONTRACT_VERSION,
@@ -164,6 +186,7 @@ export {
   ContentGraphRuntime,
   ControlPlaneClient,
   DEFAULT_GRAPH_RANKING_PROVIDER,
+  DEFAULT_TREESEED_MARKET_BASE_URL,
   EDITORIAL_PREVIEW_COOKIE,
   KNOWLEDGE_COOP_AGENT_MESSAGE_KINDS,
   KNOWLEDGE_COOP_JOB_STATUSES,
@@ -172,6 +195,8 @@ export {
   KNOWLEDGE_COOP_TEAM_CAPABILITIES,
   KNOWLEDGE_COOP_WORKSTREAM_STATES,
   MODEL_REGISTRY,
+  MarketApiError,
+  MarketClient,
   PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION,
   RemoteTemplateCatalogClient,
   RemoteTreeseedAuthClient,
@@ -182,6 +207,9 @@ export {
   RemoteTreeseedRunnerClient,
   RemoteTreeseedSdkClient,
   ScopedAgentSdk,
+  TREESEED_CATALOG_MARKET_API_BASE_URLS_ENV,
+  TREESEED_CENTRAL_MARKET_API_BASE_URL_ENV,
+  TREESEED_MARKET_API_BASE_URL_ENV,
   TREESEED_REMOTE_CONTRACT_HEADER,
   TREESEED_REMOTE_CONTRACT_VERSION,
   TRESEED_OPERATION_SPECS,
@@ -189,6 +217,7 @@ export {
   TeamScopedR2OverlayContentRuntimeProvider,
   TreeseedOperationsSdk,
   TreeseedWorkflowSdk,
+  addMarketProfile,
   buildBuiltinModelRegistry,
   buildCopilotAllowToolArgs,
   buildKnowledgeCoopKnowledgePackPackage,
@@ -196,6 +225,7 @@ export {
   buildModelRegistry,
   buildScopedModelRegistry,
   canonicalizeFrontmatter,
+  clearMarketSession,
   collectTreeseedDependencyStatus,
   collectTreeseedReconcileStatus,
   collectTreeseedToolStatus,
@@ -224,6 +254,7 @@ export {
   importKnowledgeCoopKnowledgePack,
   installTreeseedDependencies,
   isTeamScopedR2ContentEnabled,
+  listIntegratedMarketCatalog,
   listRailwayEnvironments,
   listRailwayProjects,
   listRailwayServices,
@@ -232,6 +263,7 @@ export {
   listSdkOperationNames,
   listTreeseedOperationNames,
   listWorkflowDispatchCapabilities,
+  loadMarketRegistryState,
   loadTreeseedManifest,
   loadTreeseedTenantManifest,
   mergeModelRegistries,
@@ -257,8 +289,14 @@ export {
   readPublishedContentManifest,
   readPublishedOverlayManifest,
   reconcileTreeseedTarget,
+  removeMarketProfile,
   resolveAliasedField,
+  resolveCatalogMarketProfiles,
   resolveCloudflareR2Bucket,
+  resolveDefaultCentralMarketBaseUrl,
+  resolveIntegratedCatalogArtifactDownload,
+  resolveMarketProfile,
+  resolveMarketSession,
   resolveModelDefinition,
   resolveModelField,
   resolvePublishedContentBucketBinding,
@@ -276,11 +314,15 @@ export {
   resolveTreeseedToolCommand,
   runTreeseedCopilotTask,
   runTreeseedVerifyDriver,
+  setActiveMarketProfile,
+  setMarketSession,
   signEditorialPreviewToken,
   tenantFeatureEnabled,
   tenantModelRendered,
   upsertRailwayVariables,
   validateKnowledgeCoopManagedLaunchPrerequisites,
   validateModelFieldAliases,
-  verifyEditorialPreviewToken
+  verifyArtifactBytes,
+  verifyEditorialPreviewToken,
+  writeMarketRegistryState
 };

package/dist/market-client.d.ts

@@ -0,0 +1,195 @@
+import type { ApiPrincipal, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, TokenRefreshRequest, TokenRefreshResponse } from './remote.ts';
+export declare const DEFAULT_TREESEED_MARKET_BASE_URL = "https://api.treeseed.ai";
+export declare const TREESEED_CENTRAL_MARKET_API_BASE_URL_ENV = "TREESEED_CENTRAL_MARKET_API_BASE_URL";
+export declare const TREESEED_MARKET_API_BASE_URL_ENV = "TREESEED_MARKET_API_BASE_URL";
+export declare const TREESEED_CATALOG_MARKET_API_BASE_URLS_ENV = "TREESEED_CATALOG_MARKET_API_BASE_URLS";
+export type MarketProfileKind = 'central' | 'specialized';
+export interface MarketProfile {
+    id: string;
+    label: string;
+    baseUrl: string;
+    kind: MarketProfileKind;
+    teamId?: string | null;
+    alwaysAvailable?: boolean;
+}
+export interface MarketSession {
+    marketId: string;
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: string;
+    principal?: ApiPrincipal | null;
+}
+export interface MarketRegistryState {
+    version: 1;
+    activeMarketId: string;
+    profiles: MarketProfile[];
+}
+export interface TeamAccessSummary {
+    teamId: string;
+    roles: string[];
+    permissions: string[];
+    summary: {
+        canAdminStaging: boolean;
+        canAdminProduction: boolean;
+        canDownloadTemplates: boolean;
+        canDownloadKnowledgePacks: boolean;
+    };
+}
+export interface ProjectEnvironmentAccess {
+    projectId: string;
+    environment: 'staging' | 'prod' | string;
+    subjectType: 'user' | 'team_role' | 'api_key' | string;
+    subjectId: string;
+    role: 'viewer' | 'operator' | 'admin' | string;
+}
+export interface CatalogArtifactDownload {
+    itemId: string;
+    slug?: string;
+    kind: string;
+    version: string;
+    contentType: string;
+    sha256?: string | null;
+    downloadUrl: string;
+    expiresAt?: string | null;
+    installStrategy?: string | null;
+}
+export interface MarketCatalogSource {
+    id: string;
+    label: string;
+    baseUrl: string;
+    kind: MarketProfileKind;
+    teamId?: string | null;
+}
+export type MarketSourcedCatalogItem<T extends Record<string, unknown> = Record<string, unknown>> = T & {
+    sourceMarket: MarketCatalogSource;
+};
+export type MarketSourcedCatalogArtifactDownload = CatalogArtifactDownload & {
+    sourceMarket: MarketCatalogSource;
+};
+export interface IntegratedMarketCatalogResult<T extends Record<string, unknown> = Record<string, unknown>> {
+    ok: true;
+    payload: Array<MarketSourcedCatalogItem<T>>;
+    errors: Array<{
+        market: MarketCatalogSource;
+        status?: number;
+        error: string;
+    }>;
+}
+export interface MarketClientOptions {
+    profile: MarketProfile;
+    accessToken?: string | null;
+    fetchImpl?: typeof fetch;
+    userAgent?: string;
+}
+export declare function resolveDefaultCentralMarketBaseUrl(env?: Record<string, string | undefined>): string;
+export declare function loadMarketRegistryState(): MarketRegistryState;
+export declare function writeMarketRegistryState(state: MarketRegistryState): MarketRegistryState;
+export declare function addMarketProfile(profile: MarketProfile): MarketRegistryState;
+export declare function removeMarketProfile(id: string): MarketRegistryState;
+export declare function setActiveMarketProfile(id: string): MarketRegistryState;
+export declare function resolveMarketProfile(selector?: string | null): MarketProfile;
+export declare function resolveMarketSession(tenantRoot: string, marketId: string): MarketSession | null;
+export declare function setMarketSession(tenantRoot: string, session: MarketSession): {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: any;
+    principal: any;
+};
+export declare function clearMarketSession(tenantRoot: string, marketId?: string | null): {
+    version: number;
+    sessions: {
+        [k: string]: {
+            accessToken: string;
+            refreshToken: string;
+            expiresAt: any;
+            principal: any;
+        };
+    };
+};
+export declare function resolveCatalogMarketProfiles(selector?: string | null, env?: Record<string, string | undefined>): MarketProfile[];
+export declare class MarketApiError extends Error {
+    readonly status: number;
+    readonly payload: unknown;
+    constructor(message: string, status: number, payload: unknown);
+}
+export declare class MarketClient {
+    readonly options: MarketClientOptions;
+    private readonly baseUrl;
+    private readonly accessToken;
+    private readonly fetchImpl;
+    private readonly userAgent?;
+    constructor(options: MarketClientOptions);
+    private request;
+    startDeviceLogin(request: DeviceCodeStartRequest): Promise<DeviceCodeStartResponse>;
+    pollDeviceLogin(request: DeviceCodePollRequest): Promise<DeviceCodePollResponse>;
+    refreshToken(request: TokenRefreshRequest): Promise<TokenRefreshResponse>;
+    logout(): Promise<{
+        ok: true;
+    }>;
+    me(): Promise<{
+        ok: true;
+        payload: {
+            principal: ApiPrincipal;
+            teams: unknown[];
+        };
+    }>;
+    markets(): Promise<{
+        ok: true;
+        payload: MarketProfile[];
+    }>;
+    currentMarket(): Promise<{
+        ok: true;
+        payload: MarketProfile;
+    }>;
+    teams(): Promise<{
+        ok: true;
+        payload: unknown[];
+    }>;
+    teamMembers(teamId: string): Promise<{
+        ok: true;
+        payload: unknown[];
+    }>;
+    teamPermissions(teamId: string): Promise<{
+        ok: true;
+        payload: TeamAccessSummary;
+    }>;
+    projects(teamId?: string | null): Promise<{
+        ok: true;
+        payload: unknown[];
+    }>;
+    projectAccess(projectId: string): Promise<{
+        ok: true;
+        payload: {
+            projectId: string;
+            team: TeamAccessSummary;
+            environments: ProjectEnvironmentAccess[];
+        };
+    }>;
+    catalog(kind?: string | null): Promise<{
+        ok: true;
+        payload: unknown[];
+    }>;
+    artifactDownload(itemId: string, version: string): Promise<{
+        ok: true;
+        payload: CatalogArtifactDownload;
+    }>;
+}
+export declare function listIntegratedMarketCatalog<T extends Record<string, unknown> = Record<string, unknown>>({ kind, selector, authRoot, fetchImpl, userAgent, }: {
+    kind?: string | null;
+    selector?: string | null;
+    authRoot?: string | null;
+    fetchImpl?: typeof fetch;
+    userAgent?: string;
+}): Promise<IntegratedMarketCatalogResult<T>>;
+export declare function resolveIntegratedCatalogArtifactDownload({ itemId, version, selector, authRoot, fetchImpl, userAgent, }: {
+    itemId: string;
+    version: string;
+    selector?: string | null;
+    authRoot?: string | null;
+    fetchImpl?: typeof fetch;
+    userAgent?: string;
+}): Promise<{
+    ok: true;
+    payload: MarketSourcedCatalogArtifactDownload;
+}>;
+export declare function verifyArtifactBytes(response: Response, expectedSha256?: string | null): Promise<Uint8Array<ArrayBuffer>>;

package/dist/market-client.js

@@ -0,0 +1,431 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import {
+  TREESEED_REMOTE_CONTRACT_HEADER,
+  TREESEED_REMOTE_CONTRACT_VERSION
+} from "./remote.js";
+import {
+  resolveTreeseedRemoteSession,
+  setTreeseedRemoteSession,
+  clearTreeseedRemoteSession
+} from "./operations/services/config-runtime.js";
+const DEFAULT_TREESEED_MARKET_BASE_URL = "https://api.treeseed.ai";
+const TREESEED_CENTRAL_MARKET_API_BASE_URL_ENV = "TREESEED_CENTRAL_MARKET_API_BASE_URL";
+const TREESEED_MARKET_API_BASE_URL_ENV = "TREESEED_MARKET_API_BASE_URL";
+const TREESEED_CATALOG_MARKET_API_BASE_URLS_ENV = "TREESEED_CATALOG_MARKET_API_BASE_URLS";
+const MARKET_REGISTRY_RELATIVE_PATH = ".treeseed/config/markets.json";
+function envValue(name, env = process.env) {
+  return typeof env[name] === "string" && env[name].trim().length > 0 ? env[name].trim() : null;
+}
+function resolveDefaultCentralMarketBaseUrl(env = process.env) {
+  return normalizeBaseUrl(
+    envValue(TREESEED_CENTRAL_MARKET_API_BASE_URL_ENV, env) ?? envValue(TREESEED_MARKET_API_BASE_URL_ENV, env) ?? DEFAULT_TREESEED_MARKET_BASE_URL
+  );
+}
+function defaultCentralMarket() {
+  return {
+    id: "central",
+    label: "TreeSeed Central Market",
+    baseUrl: resolveDefaultCentralMarketBaseUrl(),
+    kind: "central",
+    alwaysAvailable: true
+  };
+}
+function homeConfigPath() {
+  const homeRoot = process.env.HOME && process.env.HOME.trim().length > 0 ? process.env.HOME : homedir();
+  return resolve(homeRoot, MARKET_REGISTRY_RELATIVE_PATH);
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.trim().replace(/\/+$/u, "");
+}
+function normalizeProfile(profile) {
+  return {
+    ...profile,
+    id: profile.id.trim(),
+    label: profile.label.trim() || profile.id.trim(),
+    baseUrl: normalizeBaseUrl(profile.baseUrl),
+    kind: profile.kind === "specialized" ? "specialized" : "central",
+    teamId: profile.teamId ?? null,
+    alwaysAvailable: profile.alwaysAvailable === true || profile.id === "central"
+  };
+}
+function uniqueProfiles(profiles) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const profile of [defaultCentralMarket(), ...profiles].map(normalizeProfile)) {
+    if (profile.id === "central") {
+      profile.baseUrl = resolveDefaultCentralMarketBaseUrl();
+      profile.label = profile.label || "TreeSeed Central Market";
+      profile.kind = "central";
+      profile.alwaysAvailable = true;
+    }
+    byId.set(profile.id, profile);
+  }
+  return [...byId.values()].sort((left, right) => {
+    if (left.id === "central") return -1;
+    if (right.id === "central") return 1;
+    return left.id.localeCompare(right.id);
+  });
+}
+function loadMarketRegistryState() {
+  const path = homeConfigPath();
+  if (!existsSync(path)) {
+    return {
+      version: 1,
+      activeMarketId: "central",
+      profiles: [defaultCentralMarket()]
+    };
+  }
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  const profiles = uniqueProfiles(Array.isArray(parsed.profiles) ? parsed.profiles : []);
+  const activeMarketId = typeof parsed.activeMarketId === "string" && profiles.some((profile) => profile.id === parsed.activeMarketId) ? parsed.activeMarketId : "central";
+  return {
+    version: 1,
+    activeMarketId,
+    profiles
+  };
+}
+function writeMarketRegistryState(state) {
+  const path = homeConfigPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const profiles = uniqueProfiles(state.profiles);
+  const activeMarketId = profiles.some((profile) => profile.id === state.activeMarketId) ? state.activeMarketId : "central";
+  const next = {
+    version: 1,
+    activeMarketId,
+    profiles
+  };
+  writeFileSync(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  return next;
+}
+function addMarketProfile(profile) {
+  const state = loadMarketRegistryState();
+  return writeMarketRegistryState({
+    ...state,
+    profiles: uniqueProfiles([...state.profiles, profile])
+  });
+}
+function removeMarketProfile(id) {
+  if (id === "central") {
+    throw new Error("The central market profile cannot be removed.");
+  }
+  const state = loadMarketRegistryState();
+  return writeMarketRegistryState({
+    ...state,
+    activeMarketId: state.activeMarketId === id ? "central" : state.activeMarketId,
+    profiles: state.profiles.filter((profile) => profile.id !== id)
+  });
+}
+function setActiveMarketProfile(id) {
+  const state = loadMarketRegistryState();
+  if (!state.profiles.some((profile) => profile.id === id)) {
+    throw new Error(`Unknown market profile "${id}".`);
+  }
+  return writeMarketRegistryState({
+    ...state,
+    activeMarketId: id
+  });
+}
+function resolveMarketProfile(selector) {
+  const state = loadMarketRegistryState();
+  const trimmed = selector?.trim();
+  if (trimmed && /^https?:\/\//iu.test(trimmed)) {
+    return {
+      id: trimmed.replace(/^https?:\/\//iu, "").replace(/[^A-Za-z0-9._-]+/gu, "-").replace(/^-+|-+$/gu, "") || "market",
+      label: trimmed,
+      baseUrl: normalizeBaseUrl(trimmed),
+      kind: "specialized",
+      alwaysAvailable: false
+    };
+  }
+  const marketId = trimmed || state.activeMarketId || "central";
+  const profile = state.profiles.find((entry) => entry.id === marketId);
+  if (!profile) {
+    throw new Error(`Unknown market profile "${marketId}".`);
+  }
+  return profile;
+}
+function resolveMarketSession(tenantRoot, marketId) {
+  const session = resolveTreeseedRemoteSession(tenantRoot, marketId);
+  return session?.accessToken ? {
+    marketId,
+    accessToken: session.accessToken,
+    refreshToken: session.refreshToken,
+    expiresAt: session.expiresAt,
+    principal: session.principal ?? null
+  } : null;
+}
+function setMarketSession(tenantRoot, session) {
+  return setTreeseedRemoteSession(tenantRoot, {
+    hostId: session.marketId,
+    accessToken: session.accessToken,
+    refreshToken: session.refreshToken ?? "",
+    expiresAt: session.expiresAt ?? "",
+    principal: session.principal ?? null
+  });
+}
+function clearMarketSession(tenantRoot, marketId) {
+  return clearTreeseedRemoteSession(tenantRoot, marketId ?? void 0);
+}
+function profileToSource(profile) {
+  return {
+    id: profile.id,
+    label: profile.label,
+    baseUrl: profile.baseUrl,
+    kind: profile.kind,
+    teamId: profile.teamId ?? null
+  };
+}
+function catalogProfileIdForUrl(baseUrl) {
+  const id = normalizeBaseUrl(baseUrl).replace(/^https?:\/\//iu, "").replace(/[^A-Za-z0-9._-]+/gu, "-").replace(/^-+|-+$/gu, "");
+  return id ? `catalog-${id}` : "catalog-market";
+}
+function parseCatalogMarketBaseUrls(env = process.env) {
+  const raw = envValue(TREESEED_CATALOG_MARKET_API_BASE_URLS_ENV, env);
+  if (!raw) return [];
+  return raw.split(/[\s,]+/u).map((value) => value.trim()).filter(Boolean);
+}
+function resolveCatalogMarketProfiles(selector, env = process.env) {
+  if (selector?.trim()) {
+    return [resolveMarketProfile(selector)];
+  }
+  const state = loadMarketRegistryState();
+  const byKey = /* @__PURE__ */ new Map();
+  for (const profile of uniqueProfiles(state.profiles)) {
+    byKey.set(normalizeBaseUrl(profile.baseUrl), profile);
+  }
+  for (const baseUrl of parseCatalogMarketBaseUrls(env)) {
+    const normalized = normalizeBaseUrl(baseUrl);
+    if (!byKey.has(normalized)) {
+      byKey.set(normalized, {
+        id: catalogProfileIdForUrl(normalized),
+        label: normalized,
+        baseUrl: normalized,
+        kind: normalized === resolveDefaultCentralMarketBaseUrl(env) ? "central" : "specialized",
+        alwaysAvailable: normalized === resolveDefaultCentralMarketBaseUrl(env)
+      });
+    }
+  }
+  return [...byKey.values()].sort((left, right) => {
+    if (left.id === "central") return -1;
+    if (right.id === "central") return 1;
+    return left.id.localeCompare(right.id);
+  });
+}
+class MarketApiError extends Error {
+  constructor(message, status, payload) {
+    super(message);
+    this.status = status;
+    this.payload = payload;
+    this.name = "MarketApiError";
+  }
+  status;
+  payload;
+}
+class MarketClient {
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = normalizeBaseUrl(options.profile.baseUrl);
+    this.accessToken = options.accessToken ?? null;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.userAgent = options.userAgent;
+  }
+  options;
+  baseUrl;
+  accessToken;
+  fetchImpl;
+  userAgent;
+  async request(path, options = {}) {
+    const headers = {
+      accept: "application/json",
+      [TREESEED_REMOTE_CONTRACT_HEADER]: String(TREESEED_REMOTE_CONTRACT_VERSION)
+    };
+    if (this.userAgent) {
+      headers["user-agent"] = this.userAgent;
+    }
+    if (options.body !== void 0) {
+      headers["content-type"] = "application/json";
+    }
+    if ((options.requireAuth ?? false) && this.accessToken) {
+      headers.authorization = `Bearer ${this.accessToken}`;
+    }
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const error = typeof payload.error === "string" ? String(payload.error) : `Market request failed with ${response.status}.`;
+      throw new MarketApiError(error, response.status, payload);
+    }
+    return payload;
+  }
+  startDeviceLogin(request) {
+    return this.request("/v1/auth/device/start", {
+      method: "POST",
+      body: request
+    });
+  }
+  pollDeviceLogin(request) {
+    return this.request("/v1/auth/device/poll", {
+      method: "POST",
+      body: request
+    });
+  }
+  refreshToken(request) {
+    return this.request("/v1/auth/token/refresh", {
+      method: "POST",
+      body: request
+    });
+  }
+  logout() {
+    return this.request("/v1/auth/logout", {
+      method: "POST",
+      requireAuth: true
+    });
+  }
+  me() {
+    return this.request("/v1/me", { requireAuth: true });
+  }
+  markets() {
+    return this.request("/v1/me/markets", { requireAuth: true });
+  }
+  currentMarket() {
+    return this.request("/v1/markets/current");
+  }
+  teams() {
+    return this.request("/v1/teams", { requireAuth: true });
+  }
+  teamMembers(teamId) {
+    return this.request(`/v1/teams/${encodeURIComponent(teamId)}/members`, { requireAuth: true });
+  }
+  teamPermissions(teamId) {
+    return this.request(`/v1/teams/${encodeURIComponent(teamId)}/permissions`, { requireAuth: true });
+  }
+  projects(teamId) {
+    const query = teamId ? `?teamId=${encodeURIComponent(teamId)}` : "";
+    return this.request(`/v1/projects${query}`, { requireAuth: true });
+  }
+  projectAccess(projectId) {
+    return this.request(
+      `/v1/projects/${encodeURIComponent(projectId)}/access`,
+      { requireAuth: true }
+    );
+  }
+  catalog(kind) {
+    const query = kind ? `?kind=${encodeURIComponent(kind)}` : "";
+    return this.request(`/v1/catalog${query}`, { requireAuth: Boolean(this.accessToken) });
+  }
+  artifactDownload(itemId, version) {
+    return this.request(
+      `/v1/catalog/${encodeURIComponent(itemId)}/artifacts/${encodeURIComponent(version)}/download`,
+      { requireAuth: Boolean(this.accessToken) }
+    );
+  }
+}
+async function listIntegratedMarketCatalog({
+  kind,
+  selector,
+  authRoot,
+  fetchImpl,
+  userAgent
+}) {
+  const payload = [];
+  const errors = [];
+  for (const profile of resolveCatalogMarketProfiles(selector)) {
+    const session = authRoot ? resolveMarketSession(authRoot, profile.id) : null;
+    const client = new MarketClient({
+      profile,
+      accessToken: session?.accessToken ?? null,
+      fetchImpl,
+      userAgent
+    });
+    try {
+      const response = await client.catalog(kind);
+      for (const item of response.payload) {
+        payload.push({
+          ...item,
+          sourceMarket: profileToSource(profile)
+        });
+      }
+    } catch (error) {
+      errors.push({
+        market: profileToSource(profile),
+        status: error instanceof MarketApiError ? error.status : void 0,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { ok: true, payload, errors };
+}
+async function resolveIntegratedCatalogArtifactDownload({
+  itemId,
+  version,
+  selector,
+  authRoot,
+  fetchImpl,
+  userAgent
+}) {
+  const errors = [];
+  for (const profile of resolveCatalogMarketProfiles(selector)) {
+    const session = authRoot ? resolveMarketSession(authRoot, profile.id) : null;
+    const client = new MarketClient({
+      profile,
+      accessToken: session?.accessToken ?? null,
+      fetchImpl,
+      userAgent
+    });
+    try {
+      const response = await client.artifactDownload(itemId, version);
+      return {
+        ok: true,
+        payload: {
+          ...response.payload,
+          sourceMarket: profileToSource(profile)
+        }
+      };
+    } catch (error) {
+      if (error instanceof MarketApiError && error.status === 404) {
+        continue;
+      }
+      errors.push(`${profile.id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const suffix = errors.length > 0 ? ` Errors: ${errors.join("; ")}` : "";
+  throw new Error(`Catalog artifact "${itemId}" version "${version}" was not found in the selected market catalogs.${suffix}`);
+}
+async function verifyArtifactBytes(response, expectedSha256) {
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  if (expectedSha256) {
+    const actual = createHash("sha256").update(bytes).digest("hex");
+    if (actual !== expectedSha256) {
+      throw new Error(`Artifact checksum mismatch. Expected ${expectedSha256}, received ${actual}.`);
+    }
+  }
+  return bytes;
+}
+export {
+  DEFAULT_TREESEED_MARKET_BASE_URL,
+  MarketApiError,
+  MarketClient,
+  TREESEED_CATALOG_MARKET_API_BASE_URLS_ENV,
+  TREESEED_CENTRAL_MARKET_API_BASE_URL_ENV,
+  TREESEED_MARKET_API_BASE_URL_ENV,
+  addMarketProfile,
+  clearMarketSession,
+  listIntegratedMarketCatalog,
+  loadMarketRegistryState,
+  removeMarketProfile,
+  resolveCatalogMarketProfiles,
+  resolveDefaultCentralMarketBaseUrl,
+  resolveIntegratedCatalogArtifactDownload,
+  resolveMarketProfile,
+  resolveMarketSession,
+  setActiveMarketProfile,
+  setMarketSession,
+  verifyArtifactBytes,
+  writeMarketRegistryState
+};

package/dist/operations/services/deploy.d.ts

@@ -26,7 +26,9 @@ export declare function buildPublicVars(deployConfig: any): {
     TREESEED_HUB_MODE: any;
     TREESEED_RUNTIME_MODE: any;
     TREESEED_RUNTIME_REGISTRATION: any;
+    TREESEED_CENTRAL_MARKET_API_BASE_URL: string;
     TREESEED_MARKET_API_BASE_URL: any;
+    TREESEED_CATALOG_MARKET_API_BASE_URLS: any;
     TREESEED_HOSTING_TEAM_ID: string;
     TREESEED_PROJECT_ID: string;
     TREESEED_AGENT_EXECUTION_PROVIDER: any;

package/dist/operations/services/deploy.js

@@ -8,6 +8,7 @@ import { normalizeRailwayEnvironmentName } from "./railway-api.js";
 import { loadCliDeployConfig, resolveWranglerBin } from "./runtime-tools.js";
 const DEFAULT_COMPATIBILITY_DATE = "2026-04-05";
 const DEFAULT_COMPATIBILITY_FLAGS = ["nodejs_compat"];
+const DEFAULT_TREESEED_MARKET_BASE_URL = "https://api.treeseed.ai";
 const GENERATED_ROOT = ".treeseed/generated";
 const STATE_ROOT = ".treeseed/state";
 const WORKTREE_METADATA_RELATIVE_PATH = ".treeseed/worktree.json";
@@ -267,7 +268,9 @@ function buildPublicVars(deployConfig) {
     TREESEED_HUB_MODE: deployConfig.hub?.mode ?? "treeseed_hosted",
     TREESEED_RUNTIME_MODE: deployConfig.runtime?.mode ?? "none",
     TREESEED_RUNTIME_REGISTRATION: deployConfig.runtime?.registration ?? "none",
+    TREESEED_CENTRAL_MARKET_API_BASE_URL: envOrNull("TREESEED_CENTRAL_MARKET_API_BASE_URL") ?? DEFAULT_TREESEED_MARKET_BASE_URL,
     TREESEED_MARKET_API_BASE_URL: resolveConfiguredMarketBaseUrl(deployConfig),
+    TREESEED_CATALOG_MARKET_API_BASE_URLS: envOrNull("TREESEED_CATALOG_MARKET_API_BASE_URLS") ?? resolveConfiguredMarketBaseUrl(deployConfig),
     TREESEED_HOSTING_TEAM_ID: contentDefaultTeamId,
     TREESEED_PROJECT_ID: identity.projectId,
     TREESEED_AGENT_EXECUTION_PROVIDER: deployConfig.providers?.agents?.execution ?? "stub",
@@ -1405,7 +1408,7 @@ function resolveConfiguredCloudflareAccountId(deployConfig) {
   return envOrNull("CLOUDFLARE_ACCOUNT_ID") ?? deployConfig.cloudflare.accountId;
 }
 function resolveConfiguredMarketBaseUrl(deployConfig) {
-  return envOrNull("TREESEED_MARKET_API_BASE_URL") ?? deployConfig.runtime?.marketBaseUrl ?? deployConfig.hosting?.marketBaseUrl ?? "";
+  return envOrNull("TREESEED_MARKET_API_BASE_URL") ?? envOrNull("TREESEED_CENTRAL_MARKET_API_BASE_URL") ?? deployConfig.runtime?.marketBaseUrl ?? deployConfig.hosting?.marketBaseUrl ?? DEFAULT_TREESEED_MARKET_BASE_URL;
 }
 function resolveConfiguredPagesProjectName(deployConfig) {
   return sharedDeploymentName(resolveTreeseedResourceIdentity(deployConfig, createPersistentDeployTarget("prod")));

package/dist/platform/env.yaml

@@ -365,11 +365,36 @@ entries:
       - process-env
       - treeseed.site.yaml
     defaultValueRef: hostingRegistrationDefault
+  TREESEED_CENTRAL_MARKET_API_BASE_URL:
+    label: Treeseed central market API base URL
+    group: hosting
+    description: Base URL for the always-available central TreeSeed market used when no team-specific specialized market is selected.
+    howToGet: The production TreeSeed market defaults to https://api.treeseed.ai. Set this only when an environment should use another central-compatible market endpoint.
+    sensitivity: plain
+    targets:
+      - github-variable
+      - railway-var
+      - config-file
+    scopes:
+      - staging
+      - prod
+    storage: shared
+    requirement: optional
+    purposes:
+      - deploy
+      - config
+    validation:
+      kind: url
+    sourcePriority:
+      - machine-config
+      - process-env
+      - treeseed.site.yaml
+    defaultValueRef: centralMarketBaseUrlDefault
   TREESEED_MARKET_API_BASE_URL:
-    label: Treeseed market API base URL
+    label: Treeseed default market API base URL
     group: hosting
-    description: Base URL for the market control-plane API used by hosted and optionally registered self-hosted project platforms.
-    howToGet: Use the hosted market API URL if Treeseed manages the project for you. Self-hosted deployments should only set this when registration with the market control plane is enabled.
+    description: Primary market control-plane API URL used by hosted and optionally registered self-hosted project platforms.
+    howToGet: The production TreeSeed market defaults to https://api.treeseed.ai. Set this to a staging, enterprise, or specialized market endpoint when that environment should register with a different market.
     sensitivity: plain
     targets:
       - github-variable
@@ -391,6 +416,31 @@ entries:
     relevanceRef: projectRegistrationEnabled
     requiredWhenRef: projectRegistrationEnabled
     defaultValueRef: marketBaseUrlDefault
+  TREESEED_CATALOG_MARKET_API_BASE_URLS:
+    label: Treeseed catalog market API URLs
+    group: hosting
+    description: Comma-separated market API base URLs that contribute templates, knowledge packs, and shared resources to the integrated catalog.
+    howToGet: Start with the production TreeSeed market at https://api.treeseed.ai and add specialized team or enterprise market API URLs as needed.
+    sensitivity: plain
+    targets:
+      - github-variable
+      - railway-var
+      - config-file
+    scopes:
+      - staging
+      - prod
+    storage: shared
+    requirement: optional
+    purposes:
+      - deploy
+      - config
+    validation:
+      kind: string
+    sourcePriority:
+      - machine-config
+      - process-env
+      - treeseed.site.yaml
+    defaultValueRef: catalogMarketBaseUrlsDefault
   TREESEED_HOSTING_TEAM_ID:
     label: Hosted team ID
     group: hosting

package/dist/platform/environment.js

@@ -36,6 +36,7 @@ function resolveCoreEnvironmentPath() {
 }
 const CORE_ENVIRONMENT_PATH = resolveCoreEnvironmentPath();
 const TENANT_ENVIRONMENT_OVERLAY_PATH = "src/env.yaml";
+const DEFAULT_TREESEED_MARKET_BASE_URL = "https://api.treeseed.ai";
 function loadOptionalTenantConfig() {
   try {
     return loadTreeseedManifest();
@@ -189,7 +190,13 @@ function resolveContentBucketBinding(context) {
   return context.deployConfig.cloudflare.r2?.binding?.trim() || "TREESEED_CONTENT_BUCKET";
 }
 function resolveMarketBaseUrl(context, _scope, values = {}) {
-  return values.TREESEED_API_BASE_URL?.trim() || context.deployConfig.services?.api?.environments?.prod?.baseUrl?.trim() || "https://api.treeseed.ai";
+  return values.TREESEED_MARKET_API_BASE_URL?.trim() || values.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || process.env.TREESEED_MARKET_API_BASE_URL?.trim() || process.env.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || context.deployConfig.runtime?.marketBaseUrl?.trim() || context.deployConfig.hosting?.marketBaseUrl?.trim() || DEFAULT_TREESEED_MARKET_BASE_URL;
+}
+function resolveCentralMarketBaseUrl(context, scope, values = {}) {
+  return values.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || process.env.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || resolveMarketBaseUrl(context, scope, values) || DEFAULT_TREESEED_MARKET_BASE_URL;
+}
+function resolveCatalogMarketBaseUrls(context, scope, values = {}) {
+  return values.TREESEED_CATALOG_MARKET_API_BASE_URLS?.trim() || values.TREESEED_MARKET_API_BASE_URL?.trim() || values.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || process.env.TREESEED_CATALOG_MARKET_API_BASE_URLS?.trim() || resolveCentralMarketBaseUrl(context, scope, values);
 }
 function resolveHostedTeamId(context) {
   return context.deployConfig.slug;
@@ -248,7 +255,9 @@ const VALUE_RESOLVERS = {
   hubModeDefault: (context) => resolveHubMode(context),
   runtimeModeDefault: (context) => resolveRuntimeMode(context),
   runtimeRegistrationDefault: (context) => resolveRuntimeRegistration(context),
-  marketBaseUrlDefault: (context) => resolveMarketBaseUrl(context),
+  marketBaseUrlDefault: (context, scope, values) => resolveMarketBaseUrl(context, scope, values),
+  centralMarketBaseUrlDefault: (context, scope, values) => resolveCentralMarketBaseUrl(context, scope, values),
+  catalogMarketBaseUrlsDefault: (context, scope, values) => resolveCatalogMarketBaseUrls(context, scope, values),
   hostingTeamIdDefault: (context) => resolveHostedTeamId(context),
   hostingProjectIdDefault: (context) => resolveHostedProjectId(context),
   railwayWorkspaceDefault: () => resolveRailwayWorkspaceDefault(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.6.26",
+  "version": "0.6.28",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -113,6 +113,10 @@
       "types": "./dist/workflow-support.d.ts",
       "default": "./dist/workflow-support.js"
     },
+    "./market-client": {
+      "types": "./dist/market-client.d.ts",
+      "default": "./dist/market-client.js"
+    },
     "./reconcile": {
       "types": "./dist/reconcile/index.d.ts",
       "default": "./dist/reconcile/index.js"