memorysync-sdk 1.2.0 → 1.4.0

package/dist/index.js

@@ -21,13 +21,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AuthError: () => AuthError,
+  ConnectionOAuthNamespace: () => ConnectionOAuthNamespace,
+  ConnectionsNamespace: () => ConnectionsNamespace,
   ControlPlaneClient: () => ControlPlaneClient,
+  GoogleDriveNamespace: () => GoogleDriveNamespace,
+  GranolaNamespace: () => GranolaNamespace,
+  IntegrationsNamespace: () => IntegrationsNamespace,
   MemorySyncClient: () => MemorySyncClient,
   MemorySyncError: () => MemorySyncError,
   NotFoundError: () => NotFoundError,
+  ObjectsNamespace: () => ObjectsNamespace,
+  ProvidersNamespace: () => ProvidersNamespace,
   RateLimitError: () => RateLimitError,
+  S3Namespace: () => S3Namespace,
   ServerError: () => ServerError,
-  ValidationError: () => ValidationError
+  SlackNamespace: () => SlackNamespace,
+  SyncJobsNamespace: () => SyncJobsNamespace,
+  ValidationError: () => ValidationError,
+  WebCrawlerNamespace: () => WebCrawlerNamespace
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -73,8 +84,499 @@ var ServerError = class extends MemorySyncError {
   }
 };
 
+// src/connections.ts
+var V2 = "/api/v2/integrations";
+var V1 = "/api/v1/integrations";
+function seg(value) {
+  return encodeURIComponent(String(value));
+}
+function asItem(value, key) {
+  return typeof value === "string" ? { [key]: value } : value;
+}
+var Namespace = class {
+  constructor(request) {
+    this.req = request;
+  }
+};
+var SlackNamespace = class extends Namespace {
+  /**
+   * Channels the app can see and could be added.
+   *
+   * Private channels appear only where the deployment allows them *and* a human
+   * has invited the app, so this never widens what someone already granted.
+   */
+  availableChannels(connectionId, query) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/slack/available-channels`, { query });
+  }
+  /** Channels currently selected for syncing. */
+  channels(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/slack/channels`);
+  }
+  /**
+   * Select channels for syncing.
+   *
+   * Accepts bare channel ids, which is the common case, or objects carrying the
+   * name and type across so the server does not have to look them up again:
+   *
+   * ```ts
+   * await client.connections.slack.addChannels("c1", ["C0123", "C0456"]);
+   * await client.connections.slack.addChannels("c1", [
+   *   { id: "C0123", name: "support", is_private: false },
+   * ]);
+   * ```
+   */
+  addChannels(connectionId, channels) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/slack/channels`, {
+      body: { channels: channels.map((c) => asItem(c, "id")) }
+    });
+  }
+  /** Stop syncing one channel. */
+  removeChannel(connectionId, channelId) {
+    return this.req(
+      "DELETE",
+      `${V2}/connections/${seg(connectionId)}/slack/channels/${seg(channelId)}`
+    );
+  }
+  /**
+   * Channels this connection will never sync.
+   *
+   * The deployment-wide floor cannot be removed here; a tenant may only add to it.
+   */
+  exclusionPolicy(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/slack/exclusion-policy`);
+  }
+  /** Replace this connection's additions to the exclusion policy. */
+  setExclusionPolicy(connectionId, policy) {
+    return this.req("PUT", `${V2}/connections/${seg(connectionId)}/slack/exclusion-policy`, {
+      body: policy
+    });
+  }
+  /** Slack users seen on this connection and who they map to. */
+  identities(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/slack/identities`);
+  }
+  /** Map a Slack user to a MemorySync end user. */
+  linkIdentity(connectionId, body) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/slack/identities/link`, { body });
+  }
+  /** Re-read the Slack member list and refresh the identity table. */
+  syncIdentities(connectionId) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/slack/identities/sync`);
+  }
+};
+var GoogleDriveNamespace = class extends Namespace {
+  /** Config for rendering Google's own file picker in your UI. */
+  pickerConfig(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/gdrive/picker-config`);
+  }
+  /** Files and folders selected for syncing. */
+  resources(connectionId, query) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/gdrive/resources`, { query });
+  }
+  /** Select files or folders for syncing. */
+  addResources(connectionId, body) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/gdrive/resources`, { body });
+  }
+  /** Stop syncing one file or folder. */
+  removeResource(connectionId, resourceId) {
+    return this.req(
+      "DELETE",
+      `${V2}/connections/${seg(connectionId)}/gdrive/resources/${seg(resourceId)}`
+    );
+  }
+};
+var S3Namespace = class extends Namespace {
+  /** Prefixes visible in the bucket that could be added. */
+  availablePrefixes(connectionId, query) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/s3/available-prefixes`, { query });
+  }
+  /** Prefixes currently selected for syncing. */
+  prefixes(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/s3/prefixes`);
+  }
+  /**
+   * Select prefixes for syncing.
+   *
+   * Accepts bare prefixes, or objects carrying `bucket` and `label`:
+   *
+   * ```ts
+   * await client.connections.s3.addPrefixes("c1", ["handbook/", "policies/"]);
+   * await client.connections.s3.addPrefixes("c1", [
+   *   { prefix: "handbook/", label: "Handbook" },
+   * ]);
+   * ```
+   *
+   * An empty string means the bucket root. The bucket defaults to the one the
+   * connection's credentials were validated against, and the API rejects any
+   * other bucket rather than indexing one nobody proved access to.
+   */
+  addPrefixes(connectionId, prefixes) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/s3/prefixes`, {
+      body: { prefixes: prefixes.map((p) => asItem(p, "prefix")) }
+    });
+  }
+  /**
+   * Revoke one prefix approval, optionally purging what it produced.
+   *
+   * The prefix travels as a query parameter, not in the body and not as a path
+   * segment: prefixes contain slashes, which a path segment cannot carry
+   * unambiguously, and this endpoint reads no body at all.
+   *
+   * Pass `purge: true` to also delete the memories already derived from the
+   * prefix. The default leaves them in place, so revoking an approval does not
+   * silently destroy knowledge.
+   */
+  removePrefix(connectionId, prefix = "", options = {}) {
+    const query = { prefix, purge: options.purge ?? false };
+    if (options.bucket !== void 0) query.bucket = options.bucket;
+    return this.req("DELETE", `${V2}/connections/${seg(connectionId)}/s3/prefixes`, { query });
+  }
+  /** Keys and patterns this connection will never sync. */
+  exclusionPolicy(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/s3/exclusion-policy`);
+  }
+  /** Replace this connection's additions to the exclusion policy. */
+  setExclusionPolicy(connectionId, policy) {
+    return this.req("PUT", `${V2}/connections/${seg(connectionId)}/s3/exclusion-policy`, {
+      body: policy
+    });
+  }
+  /** Effective S3 settings, including the per-object size ceiling. */
+  settings(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/s3/settings`);
+  }
+};
+var GranolaNamespace = class extends Namespace {
+  /** Folders that could be added. */
+  availableFolders(connectionId, query) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/granola/available-folders`, { query });
+  }
+  /** Folders currently selected for syncing. */
+  folders(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/granola/folders`);
+  }
+  /** Select folders for syncing. */
+  addFolders(connectionId, body) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/granola/folders`, { body });
+  }
+  /** Stop syncing one folder. */
+  removeFolder(connectionId, folderId) {
+    return this.req(
+      "DELETE",
+      `${V2}/connections/${seg(connectionId)}/granola/folders/${seg(folderId)}`
+    );
+  }
+  /** Folders and meetings this connection will never sync. */
+  exclusionPolicy(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/granola/exclusion-policy`);
+  }
+  /** Replace this connection's additions to the exclusion policy. */
+  setExclusionPolicy(connectionId, policy) {
+    return this.req("PUT", `${V2}/connections/${seg(connectionId)}/granola/exclusion-policy`, {
+      body: policy
+    });
+  }
+  /** Meeting participants seen on this connection and who they map to. */
+  identities(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/granola/identities`);
+  }
+  /** Map a participant to a MemorySync end user. */
+  linkIdentity(connectionId, body) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/granola/identities/link`, { body });
+  }
+  /**
+   * Re-run identity matching for this connection.
+   *
+   * Takes no arguments: the route reads no body and re-matches the whole roster.
+   * `body` is kept optional only so a forward-compatible field can be passed
+   * once the route grows one.
+   */
+  relinkIdentity(connectionId, body = {}) {
+    const hasFields = Object.keys(body).length > 0;
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/granola/identities/relink`, {
+      body: hasFields ? body : void 0
+    });
+  }
+  /** Effective Granola settings for this connection. */
+  settings(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/granola/settings`);
+  }
+  /** Update Granola settings for this connection. */
+  setSettings(connectionId, settings) {
+    return this.req("PUT", `${V2}/connections/${seg(connectionId)}/granola/settings`, {
+      body: settings
+    });
+  }
+};
+var ConnectionOAuthNamespace = class extends Namespace {
+  /**
+   * Begin an OAuth connection and get the URL to send the user to.
+   *
+   * The user completes consent in a browser and the provider calls the platform
+   * back — not your backend. Poll {@link status} to find out how it went.
+   */
+  initiate(provider, body = {}) {
+    return this.req("POST", `${V2}/oauth/initiate`, {
+      body: { provider_id: provider, ...body }
+    });
+  }
+  /** Where an in-flight OAuth connection got to. */
+  status(query) {
+    return this.req("GET", `${V2}/oauth/status`, { query });
+  }
+};
+var ConnectionsNamespace = class extends Namespace {
+  constructor(request) {
+    super(request);
+    this.slack = new SlackNamespace(request);
+    this.gdrive = new GoogleDriveNamespace(request);
+    this.s3 = new S3Namespace(request);
+    this.granola = new GranolaNamespace(request);
+    this.oauth = new ConnectionOAuthNamespace(request);
+  }
+  /** Every connection in this organization. */
+  list(query) {
+    return this.req("GET", `${V2}/connections`, { query });
+  }
+  /** One connection, including its status and last sync. */
+  get(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}`);
+  }
+  /** Connect a provider that authenticates with an API key or bot token. */
+  /**
+   * Connect a provider that authenticates with an API key or bot token.
+   *
+   * The wire field is `provider_id`; the argument is named `provider` because
+   * that is what the rest of this namespace calls it.
+   */
+  createWithApiKey(provider, apiKey, body = {}) {
+    return this.req("POST", `${V2}/connections/api-key`, {
+      body: { provider_id: provider, api_key: apiKey, ...body }
+    });
+  }
+  /** Connect a provider that needs a credential bundle, such as S3 keys. */
+  createWithCredentials(provider, credentials, body = {}) {
+    return this.req("POST", `${V2}/connections/credentials`, {
+      body: { provider_id: provider, credentials, ...body }
+    });
+  }
+  /** Change a connection's name, schedule or settings. */
+  update(connectionId, body) {
+    return this.req("PATCH", `${V2}/connections/${seg(connectionId)}`, { body });
+  }
+  /**
+   * Remove a connection.
+   *
+   * Stops future syncing. Memories already extracted are left in place — use
+   * {@link purge} for those, so disconnecting never silently deletes knowledge
+   * someone still depends on.
+   */
+  delete(connectionId) {
+    return this.req("DELETE", `${V2}/connections/${seg(connectionId)}`);
+  }
+  /** Re-authorise a connection whose credentials expired or were revoked. */
+  reconnect(connectionId, body = {}) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/reconnect`, { body });
+  }
+  /**
+   * Delete the memories this connection produced.
+   *
+   * Separate from {@link delete} on purpose: removing a connection and removing
+   * what it taught you are different decisions.
+   */
+  purge(connectionId, body = {}) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/purge`, { body });
+  }
+  /** Current and recent sync state for a connection. */
+  syncStatus(connectionId) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/sync`);
+  }
+  /** Start a sync now instead of waiting for the schedule. */
+  triggerSync(connectionId, body = {}) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/sync`, { body });
+  }
+  /** Objects a connection has ingested — files, messages, meetings. */
+  objects(connectionId, query) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/objects`, { query });
+  }
+  /** Object listing with richer filtering and paging than {@link objects}. */
+  objectsV2(connectionId, query) {
+    return this.req("GET", `${V2}/connections/${seg(connectionId)}/objects/v2`, { query });
+  }
+  /** Apply one action to many objects — pause, resume, re-extract. */
+  bulkObjectAction(connectionId, body) {
+    return this.req("POST", `${V2}/connections/${seg(connectionId)}/objects/bulk`, { body });
+  }
+  /** Connector totals: connections, objects synced, memories produced. */
+  stats(query) {
+    return this.req("GET", `${V2}/stats`, { query });
+  }
+  /** Audit trail of connector activity. */
+  auditLogs(query) {
+    return this.req("GET", `${V2}/audit-logs`, { query });
+  }
+};
+var ObjectsNamespace = class extends Namespace {
+  /** Metadata and sync state for one object. */
+  get(objectId) {
+    return this.req("GET", `${V2}/objects/${seg(objectId)}`);
+  }
+  /** What extraction made of this object. */
+  analysis(objectId) {
+    return this.req("GET", `${V2}/objects/${seg(objectId)}/analysis`);
+  }
+  /** Every action taken on this object. */
+  audit(objectId, query) {
+    return this.req("GET", `${V2}/objects/${seg(objectId)}/audit`, { query });
+  }
+  /** Versions of this object seen across syncs. */
+  history(objectId, query) {
+    return this.req("GET", `${V2}/objects/${seg(objectId)}/history`, { query });
+  }
+  /** Which memories this object produced, and whether extraction finished. */
+  memoryStatus(objectId) {
+    return this.req("GET", `${V2}/objects/${seg(objectId)}/memory-status`);
+  }
+  /** Row and column statistics for spreadsheet-shaped objects. */
+  structuredStats(objectId) {
+    return this.req("GET", `${V2}/objects/${seg(objectId)}/structured-stats`);
+  }
+  /** Score this object for extraction worthiness without extracting. */
+  evaluate(objectId, body = {}) {
+    return this.req("POST", `${V2}/objects/${seg(objectId)}/evaluate`, { body });
+  }
+  /** Stop re-syncing this object, leaving its memories in place. */
+  pause(objectId) {
+    return this.req("POST", `${V2}/objects/${seg(objectId)}/pause`);
+  }
+  /** Resume syncing a paused object. */
+  resume(objectId) {
+    return this.req("POST", `${V2}/objects/${seg(objectId)}/resume`);
+  }
+  /**
+   * Run extraction again over content already fetched.
+   *
+   * Counts against the plan's add allowance, exactly like the first extraction,
+   * because it creates memories the same way.
+   */
+  reextract(objectId, body = {}) {
+    return this.req("POST", `${V2}/objects/${seg(objectId)}/reextract`, { body });
+  }
+  /** Fetch this object from the provider again, then extract. */
+  resync(objectId, body = {}) {
+    return this.req("POST", `${V2}/objects/${seg(objectId)}/resync`, { body });
+  }
+  /** Remove the memories this object produced, keeping the object record. */
+  deleteMemories(objectId, query) {
+    return this.req("DELETE", `${V2}/objects/${seg(objectId)}/memories`, { query });
+  }
+};
+var ProvidersNamespace = class extends Namespace {
+  /** Every available provider and what it needs to connect. */
+  list(query) {
+    return this.req("GET", `${V2}/providers`, { query });
+  }
+  /** One provider's capabilities, scopes and settings schema. */
+  get(providerId) {
+    return this.req("GET", `${V2}/providers/${seg(providerId)}`);
+  }
+};
+var SyncJobsNamespace = class extends Namespace {
+  /** Progress and outcome of one sync run. */
+  get(jobId) {
+    return this.req("GET", `${V2}/sync-jobs/${seg(jobId)}`);
+  }
+  /** Stop a running sync. Objects already ingested are kept. */
+  cancel(jobId, body = {}) {
+    return this.req("POST", `${V2}/sync-jobs/${seg(jobId)}/cancel`, { body });
+  }
+};
+var WebCrawlerNamespace = class extends Namespace {
+  /** Check a URL is reachable and crawlable before committing to a job. */
+  validate(url, body = {}) {
+    return this.req("POST", `${V1}/web-crawler/validate`, { body: { url, ...body } });
+  }
+  /**
+   * Start a crawl. Returns a job to poll.
+   *
+   * Crawling only fetches and stores page content. Nothing becomes a memory until
+   * you call {@link importJob}, so a large crawl cannot quietly consume your add
+   * allowance.
+   */
+  crawl(url, body = {}) {
+    return this.req("POST", `${V1}/web-crawler/crawl`, { body: { url, ...body } });
+  }
+  /** Crawl jobs for this organization. */
+  jobs(query) {
+    return this.req("GET", `${V1}/web-crawler/jobs`, { query });
+  }
+  /** One crawl job's status and progress. */
+  job(jobId) {
+    return this.req("GET", `${V1}/web-crawler/jobs/${seg(jobId)}`);
+  }
+  /** Stop a running crawl. Pages already fetched are kept. */
+  cancelJob(jobId) {
+    return this.req("POST", `${V1}/web-crawler/jobs/${seg(jobId)}/cancel`);
+  }
+  /** Delete a crawl job and its fetched pages. */
+  deleteJob(jobId) {
+    return this.req("DELETE", `${V1}/web-crawler/jobs/${seg(jobId)}`);
+  }
+  /** Pages a crawl fetched, before any import. */
+  jobContent(jobId, query) {
+    return this.req("GET", `${V1}/web-crawler/jobs/${seg(jobId)}/content`, { query });
+  }
+  /** Page counts, byte totals and error breakdown for a crawl. */
+  jobStatistics(jobId) {
+    return this.req("GET", `${V1}/web-crawler/jobs/${seg(jobId)}/statistics`);
+  }
+  /**
+   * Turn a completed crawl's pages into memories.
+   *
+   * This is the step that creates memories, so this is the step that is billed —
+   * one unit per memory created, like every other ingestion path.
+   */
+  importJob(jobId, body = {}) {
+    return this.req("POST", `${V1}/web-crawler/jobs/${seg(jobId)}/import`, { body });
+  }
+  /** Crawls running right now. */
+  active() {
+    return this.req("GET", `${V1}/web-crawler/active`);
+  }
+  /** Crawler limits in force: depth, page ceiling, rate, timeouts. */
+  config() {
+    return this.req("GET", `${V1}/web-crawler/config`);
+  }
+};
+var IntegrationsNamespace = class extends Namespace {
+  constructor(request) {
+    super(request);
+    this.webCrawler = new WebCrawlerNamespace(request);
+  }
+  /** Every integration this deployment offers, for building a picker UI. */
+  catalog(query) {
+    return this.req("GET", `${V1}/catalog`, { query });
+  }
+  /** Integrations currently connected. Older view of `connections.list()`. */
+  connected(query) {
+    return this.req("GET", `${V1}/connected`, { query });
+  }
+  /** Legacy integration counters. Prefer `connections.stats()`. */
+  stats(query) {
+    return this.req("GET", `${V1}/stats`, { query });
+  }
+  /** Update a legacy integration record. */
+  update(integrationId, body) {
+    return this.req("PATCH", `${V1}/${seg(integrationId)}`, { body });
+  }
+  /** Delete a legacy integration record. */
+  delete(integrationId) {
+    return this.req("DELETE", `${V1}/${seg(integrationId)}`);
+  }
+};
+
 // src/control-plane.ts
-var SDK_VERSION = "1.1.1";
+var SDK_VERSION = "1.4.0";
 function safeJson(text) {
   try {
     return JSON.parse(text);
@@ -500,7 +1002,7 @@ var ControlPlaneClient = class {
 };
 
 // src/index.ts
-var SDK_VERSION2 = "1.2.0";
+var SDK_VERSION2 = "1.4.0";
 function camelToSnakeKey(key) {
   return key.replace(/([A-Z])/g, "_$1").toLowerCase();
 }
@@ -590,6 +1092,12 @@ var MemorySyncClient = class {
       throw new Error("No fetch implementation available. Pass `fetch` in config or use Node 18+.");
     }
     this.fetchImpl = f;
+    const request = (method, path, options) => this.request(method, path, options ?? {});
+    this.connections = new ConnectionsNamespace(request);
+    this.objects = new ObjectsNamespace(request);
+    this.providers = new ProvidersNamespace(request);
+    this.syncJobs = new SyncJobsNamespace(request);
+    this.integrations = new IntegrationsNamespace(request);
   }
   headers(extra = {}) {
     const h = {
@@ -1194,12 +1702,23 @@ function toOntology(raw) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthError,
+  ConnectionOAuthNamespace,
+  ConnectionsNamespace,
   ControlPlaneClient,
+  GoogleDriveNamespace,
+  GranolaNamespace,
+  IntegrationsNamespace,
   MemorySyncClient,
   MemorySyncError,
   NotFoundError,
+  ObjectsNamespace,
+  ProvidersNamespace,
   RateLimitError,
+  S3Namespace,
   ServerError,
-  ValidationError
+  SlackNamespace,
+  SyncJobsNamespace,
+  ValidationError,
+  WebCrawlerNamespace
 });
 //# sourceMappingURL=index.js.map