@smithery/api 0.27.0 → 0.29.0

package/src/resources/namespaces/namespaces.ts

@@ -0,0 +1,92 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as ServersAPI from './servers';
+import { CreateServerRequest, CreateServerResponse, ServerCreateParams, Servers } from './servers';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Namespaces extends APIResource {
+  servers: ServersAPI.Servers = new ServersAPI.Servers(this._client);
+
+  /**
+   * Create a new namespace with a server-generated human-readable name, owned by the
+   * authenticated user
+   *
+   * @example
+   * ```ts
+   * const namespace = await client.namespaces.create();
+   * ```
+   */
+  create(options?: RequestOptions): APIPromise<NamespaceCreateResponse> {
+    return this._client.post('/namespaces', options);
+  }
+
+  /**
+   * Get a list of all namespaces owned by the authenticated user
+   *
+   * @example
+   * ```ts
+   * const namespaces = await client.namespaces.list();
+   * ```
+   */
+  list(options?: RequestOptions): APIPromise<NamespaceListResponse> {
+    return this._client.get('/namespaces', options);
+  }
+
+  /**
+   * Create a new namespace owned by the authenticated user. This endpoint is
+   * idempotent - if the namespace already exists and is owned by the user, returns
+   * success.
+   *
+   * @example
+   * ```ts
+   * const response = await client.namespaces.set('xxx');
+   * ```
+   */
+  set(name: string, options?: RequestOptions): APIPromise<NamespaceSetResponse> {
+    return this._client.put(path`/namespaces/${name}`, options);
+  }
+}
+
+export interface NamespaceCreateResponse {
+  createdAt: string;
+
+  name: string;
+}
+
+export interface NamespaceListResponse {
+  namespaces: Array<NamespaceListResponse.Namespace>;
+}
+
+export namespace NamespaceListResponse {
+  export interface Namespace {
+    createdAt: string;
+
+    name: string;
+  }
+}
+
+export interface NamespaceSetResponse {
+  createdAt: string;
+
+  name: string;
+}
+
+Namespaces.Servers = Servers;
+
+export declare namespace Namespaces {
+  export {
+    type NamespaceCreateResponse as NamespaceCreateResponse,
+    type NamespaceListResponse as NamespaceListResponse,
+    type NamespaceSetResponse as NamespaceSetResponse,
+  };
+
+  export {
+    Servers as Servers,
+    type CreateServerRequest as CreateServerRequest,
+    type CreateServerResponse as CreateServerResponse,
+    type ServerCreateParams as ServerCreateParams,
+  };
+}

package/src/resources/namespaces/servers.ts

@@ -0,0 +1,71 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Servers extends APIResource {
+  /**
+   * Create a new server under the specified namespace. This endpoint is idempotent.
+   *
+   * @example
+   * ```ts
+   * const createServerResponse =
+   *   await client.namespaces.servers.create('xxx', {
+   *     namespace: 'namespace',
+   *   });
+   * ```
+   */
+  create(
+    server: string,
+    params: ServerCreateParams,
+    options?: RequestOptions,
+  ): APIPromise<CreateServerResponse> {
+    const { namespace, ...body } = params;
+    return this._client.put(path`/namespaces/${namespace}/servers/${server}`, { body, ...options });
+  }
+}
+
+export interface CreateServerRequest {
+  description?: string;
+
+  displayName?: string;
+}
+
+export interface CreateServerResponse {
+  createdAt: string;
+
+  description: string;
+
+  displayName: string;
+
+  namespace: string;
+
+  server: string;
+}
+
+export interface ServerCreateParams {
+  /**
+   * Path param
+   */
+  namespace: string;
+
+  /**
+   * Body param
+   */
+  description?: string;
+
+  /**
+   * Body param
+   */
+  displayName?: string;
+}
+
+export declare namespace Servers {
+  export {
+    type CreateServerRequest as CreateServerRequest,
+    type CreateServerResponse as CreateServerResponse,
+    type ServerCreateParams as ServerCreateParams,
+  };
+}

package/src/resources/namespaces.ts

@@ -1,63 +1,3 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../core/resource';
-import { APIPromise } from '../core/api-promise';
-import { RequestOptions } from '../internal/request-options';
-import { path } from '../internal/utils/path';
-
-export class Namespaces extends APIResource {
-  /**
-   * Create a new namespace with a server-generated human-readable name, owned by the
-   * authenticated user
-   */
-  create(options?: RequestOptions): APIPromise<NamespaceCreateResponse> {
-    return this._client.post('/namespaces', options);
-  }
-
-  /**
-   * Get a list of all namespaces owned by the authenticated user
-   */
-  list(options?: RequestOptions): APIPromise<NamespaceListResponse> {
-    return this._client.get('/namespaces', options);
-  }
-
-  /**
-   * Create a new namespace with a user-specified name, owned by the authenticated
-   * user
-   */
-  set(name: string, options?: RequestOptions): APIPromise<NamespaceSetResponse> {
-    return this._client.put(path`/namespaces/${name}`, options);
-  }
-}
-
-export interface NamespaceCreateResponse {
-  createdAt: string;
-
-  name: string;
-}
-
-export interface NamespaceListResponse {
-  namespaces: Array<NamespaceListResponse.Namespace>;
-}
-
-export namespace NamespaceListResponse {
-  export interface Namespace {
-    createdAt: string;
-
-    name: string;
-  }
-}
-
-export interface NamespaceSetResponse {
-  createdAt: string;
-
-  name: string;
-}
-
-export declare namespace Namespaces {
-  export {
-    type NamespaceCreateResponse as NamespaceCreateResponse,
-    type NamespaceListResponse as NamespaceListResponse,
-    type NamespaceSetResponse as NamespaceSetResponse,
-  };
-}
+export * from './namespaces/index';

package/src/resources/servers/deployments.ts

@@ -10,43 +10,81 @@ import { path } from '../../internal/utils/path';
 export class Deployments extends APIResource {
   /**
    * List deployments for a server
+   *
+   * @example
+   * ```ts
+   * const deployments = await client.servers.deployments.list(
+   *   'server',
+   *   { namespace: 'namespace' },
+   * );
+   * ```
    */
-  list(qualifiedName: string, options?: RequestOptions): APIPromise<DeploymentListResponse> {
-    return this._client.get(path`/servers/${qualifiedName}/deployments`, options);
+  list(
+    server: string,
+    params: DeploymentListParams,
+    options?: RequestOptions,
+  ): APIPromise<DeploymentListResponse> {
+    const { namespace } = params;
+    return this._client.get(path`/servers/${namespace}/${server}/deployments`, options);
   }
 
   /**
    * Upload and deploy an MCP server (hosted or external)
+   *
+   * @example
+   * ```ts
+   * const response = await client.servers.deployments.deploy(
+   *   'server',
+   *   { namespace: 'namespace', payload: 'payload' },
+   * );
+   * ```
    */
   deploy(
-    qualifiedName: string,
-    body: DeploymentDeployParams,
+    server: string,
+    params: DeploymentDeployParams,
     options?: RequestOptions,
   ): APIPromise<DeploymentDeployResponse> {
+    const { namespace, ...body } = params;
     return this._client.put(
-      path`/servers/${qualifiedName}/deployments`,
+      path`/servers/${namespace}/${server}/deployments`,
       multipartFormRequestOptions({ body, ...options }, this._client),
     );
   }
 
   /**
    * Get deployment status
+   *
+   * @example
+   * ```ts
+   * const deployment = await client.servers.deployments.get(
+   *   'id',
+   *   { namespace: 'namespace', server: 'server' },
+   * );
+   * ```
    */
   get(id: string, params: DeploymentGetParams, options?: RequestOptions): APIPromise<DeploymentGetResponse> {
-    const { qualifiedName } = params;
-    return this._client.get(path`/servers/${qualifiedName}/deployments/${id}`, options);
+    const { namespace, server } = params;
+    return this._client.get(path`/servers/${namespace}/${server}/deployments/${id}`, options);
   }
 
   /**
    * Use id='latest' to resume the most recent deployment
+   *
+   * @example
+   * ```ts
+   * const response = await client.servers.deployments.resume(
+   *   'id',
+   *   { namespace: 'namespace', server: 'server' },
+   * );
+   * ```
    */
   resume(
     id: string,
     params: DeploymentResumeParams,
     options?: RequestOptions,
   ): APIPromise<DeploymentResumeResponse> {
-    const { qualifiedName } = params;
-    return this._client.post(path`/servers/${qualifiedName}/deployments/${id}/resume`, options);
+    const { namespace, server } = params;
+    return this._client.post(path`/servers/${namespace}/${server}/deployments/${id}/resume`, options);
   }
 }
 
@@ -58,7 +96,15 @@ export type DeployPayload =
 
 export namespace DeployPayload {
   export interface RepoDeployPayload {
+    baseDirectory: string;
+
+    repoName: string;
+
+    repoOwner: string;
+
     type: 'repo';
+
+    branch?: string;
   }
 }
 
@@ -366,34 +412,48 @@ export interface DeploymentResumeResponse {
   status: string;
 }
 
+export interface DeploymentListParams {
+  namespace: string;
+}
+
 export interface DeploymentDeployParams {
   /**
-   * JSON-encoded deployment payload. See DeployPayload schema for structure.
+   * Path param
+   */
+  namespace: string;
+
+  /**
+   * Body param: JSON-encoded deployment payload. See DeployPayload schema for
+   * structure.
    */
   payload: string;
 
   /**
-   * MCPB bundle file (for stdio deployments)
+   * Body param: MCPB bundle file (for stdio deployments)
    */
   bundle?: Uploadable;
 
   /**
-   * JavaScript module file (for hosted deployments)
+   * Body param: JavaScript module file (for hosted deployments)
    */
   module?: Uploadable;
 
   /**
-   * Source map file (for hosted deployments)
+   * Body param: Source map file (for hosted deployments)
    */
   sourcemap?: Uploadable;
 }
 
 export interface DeploymentGetParams {
-  qualifiedName: string;
+  namespace: string;
+
+  server: string;
 }
 
 export interface DeploymentResumeParams {
-  qualifiedName: string;
+  namespace: string;
+
+  server: string;
 }
 
 export declare namespace Deployments {
@@ -407,6 +467,7 @@ export declare namespace Deployments {
     type DeploymentDeployResponse as DeploymentDeployResponse,
     type DeploymentGetResponse as DeploymentGetResponse,
     type DeploymentResumeResponse as DeploymentResumeResponse,
+    type DeploymentListParams as DeploymentListParams,
     type DeploymentDeployParams as DeploymentDeployParams,
     type DeploymentGetParams as DeploymentGetParams,
     type DeploymentResumeParams as DeploymentResumeParams,

package/src/resources/servers/index.ts

@@ -11,16 +11,27 @@ export {
   type DeploymentDeployResponse,
   type DeploymentGetResponse,
   type DeploymentResumeResponse,
+  type DeploymentListParams,
   type DeploymentDeployParams,
   type DeploymentGetParams,
   type DeploymentResumeParams,
 } from './deployments';
 export { Logs, type LogListResponse, type LogListParams } from './logs';
+export {
+  Repo,
+  type RepoDeleteResponse,
+  type RepoGetResponse,
+  type RepoSetResponse,
+  type RepoDeleteParams,
+  type RepoGetParams,
+  type RepoSetParams,
+} from './repo';
 export {
   Secrets,
   type SecretListResponse,
   type SecretDeleteResponse,
   type SecretSetResponse,
+  type SecretListParams,
   type SecretDeleteParams,
   type SecretSetParams,
 } from './secrets';
@@ -33,5 +44,8 @@ export {
   type ServerDeleteResponse,
   type ServerGetResponse,
   type ServerListParams,
+  type ServerDeleteParams,
+  type ServerDownloadParams,
+  type ServerGetParams,
   type ServerListResponsesSmitheryPage,
 } from './servers';

package/src/resources/servers/logs.ts

@@ -9,13 +9,17 @@ export class Logs extends APIResource {
   /**
    * Fetch recent runtime logs for the server's deployed Worker, grouped by
    * invocation (requires ownership).
+   *
+   * @example
+   * ```ts
+   * const logs = await client.servers.logs.list('server', {
+   *   namespace: 'namespace',
+   * });
+   * ```
    */
-  list(
-    qualifiedName: string,
-    query: LogListParams | null | undefined = {},
-    options?: RequestOptions,
-  ): APIPromise<LogListResponse> {
-    return this._client.get(path`/servers/${qualifiedName}/logs`, { query, ...options });
+  list(server: string, params: LogListParams, options?: RequestOptions): APIPromise<LogListResponse> {
+    const { namespace, ...query } = params;
+    return this._client.get(path`/servers/${namespace}/${server}/logs`, { query, ...options });
   }
 }
 
@@ -86,17 +90,22 @@ export namespace LogListResponse {
 
 export interface LogListParams {
   /**
-   * Start of time range (ISO 8601).
+   * Path param
+   */
+  namespace: string;
+
+  /**
+   * Query param: Start of time range (ISO 8601).
    */
   from?: string;
 
   /**
-   * Max invocations to return. Defaults to 50.
+   * Query param: Max invocations to return. Defaults to 50.
    */
   limit?: number;
 
   /**
-   * End of time range (ISO 8601).
+   * Query param: End of time range (ISO 8601).
    */
   to?: string;
 }

package/src/resources/servers/repo.ts

@@ -0,0 +1,143 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Repo extends APIResource {
+  /**
+   * Disconnect the GitHub repository connection from a server.
+   *
+   * @example
+   * ```ts
+   * const repo = await client.servers.repo.delete('server', {
+   *   namespace: 'namespace',
+   * });
+   * ```
+   */
+  delete(server: string, params: RepoDeleteParams, options?: RequestOptions): APIPromise<RepoDeleteResponse> {
+    const { namespace } = params;
+    return this._client.delete(path`/servers/${namespace}/${server}/repo`, options);
+  }
+
+  /**
+   * Get the GitHub repository connection for a server, if one exists.
+   *
+   * @example
+   * ```ts
+   * const repo = await client.servers.repo.get('server', {
+   *   namespace: 'namespace',
+   * });
+   * ```
+   */
+  get(server: string, params: RepoGetParams, options?: RequestOptions): APIPromise<RepoGetResponse> {
+    const { namespace } = params;
+    return this._client.get(path`/servers/${namespace}/${server}/repo`, options);
+  }
+
+  /**
+   * Upsert a GitHub repository connection for a server. Creates a new connection if
+   * none exists, or updates the existing one.
+   *
+   * @example
+   * ```ts
+   * const response = await client.servers.repo.set('server', {
+   *   namespace: 'namespace',
+   *   repoName: 'x',
+   *   repoOwner: 'x',
+   * });
+   * ```
+   */
+  set(server: string, params: RepoSetParams, options?: RequestOptions): APIPromise<RepoSetResponse> {
+    const { namespace, ...body } = params;
+    return this._client.put(path`/servers/${namespace}/${server}/repo`, { body, ...options });
+  }
+}
+
+export interface RepoDeleteResponse {
+  success: boolean;
+}
+
+export interface RepoGetResponse {
+  autoDeploy: boolean | null;
+
+  baseDirectory: string;
+
+  branch: string | null;
+
+  isPrivate: boolean;
+
+  repoName: string;
+
+  repoOwner: string;
+
+  type: 'github';
+}
+
+export interface RepoSetResponse {
+  autoDeploy: boolean | null;
+
+  baseDirectory: string;
+
+  branch: string | null;
+
+  isPrivate: boolean;
+
+  repoName: string;
+
+  repoOwner: string;
+
+  type: 'github';
+}
+
+export interface RepoDeleteParams {
+  namespace: string;
+}
+
+export interface RepoGetParams {
+  namespace: string;
+}
+
+export interface RepoSetParams {
+  /**
+   * Path param
+   */
+  namespace: string;
+
+  /**
+   * Body param
+   */
+  repoName: string;
+
+  /**
+   * Body param
+   */
+  repoOwner: string;
+
+  /**
+   * Body param
+   */
+  autoDeploy?: boolean;
+
+  /**
+   * Body param
+   */
+  baseDirectory?: string;
+
+  /**
+   * Body param
+   */
+  branch?: string | null;
+}
+
+export declare namespace Repo {
+  export {
+    type RepoDeleteResponse as RepoDeleteResponse,
+    type RepoGetResponse as RepoGetResponse,
+    type RepoSetResponse as RepoSetResponse,
+    type RepoDeleteParams as RepoDeleteParams,
+    type RepoGetParams as RepoGetParams,
+    type RepoSetParams as RepoSetParams,
+  };
+}