@smithery/api 0.46.0 → 0.47.0

package/src/resources/servers/domains.ts

@@ -0,0 +1,270 @@
+// 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 Domains extends APIResource {
+  /**
+   * Add a managed run.tools or custom domain.
+   *
+   * @example
+   * ```ts
+   * const domain = await client.servers.domains.create(
+   *   'qualifiedName',
+   *   { subdomain: 'subdomain', type: 'managed' },
+   * );
+   * ```
+   */
+  create(
+    qualifiedName: string,
+    body: DomainCreateParams,
+    options?: RequestOptions,
+  ): APIPromise<DomainCreateResponse> {
+    return this._client.post(path`/servers/${qualifiedName}/domains`, { body, ...options });
+  }
+
+  /**
+   * Update domain settings such as subdomain slug or authentication requirements.
+   *
+   * @example
+   * ```ts
+   * const domain = await client.servers.domains.update(
+   *   'domainId',
+   *   { qualifiedName: 'qualifiedName' },
+   * );
+   * ```
+   */
+  update(
+    domainID: string,
+    params: DomainUpdateParams,
+    options?: RequestOptions,
+  ): APIPromise<DomainUpdateResponse> {
+    const { qualifiedName, ...body } = params;
+    return this._client.patch(path`/servers/${qualifiedName}/domains/${domainID}`, { body, ...options });
+  }
+
+  /**
+   * List all domains, including managed run.tools and custom domains.
+   *
+   * @example
+   * ```ts
+   * const domains = await client.servers.domains.list(
+   *   'qualifiedName',
+   * );
+   * ```
+   */
+  list(qualifiedName: string, options?: RequestOptions): APIPromise<DomainListResponse> {
+    return this._client.get(path`/servers/${qualifiedName}/domains`, options);
+  }
+
+  /**
+   * Remove a domain and clean up associated DNS records.
+   *
+   * @example
+   * ```ts
+   * const domain = await client.servers.domains.delete(
+   *   'domainId',
+   *   { qualifiedName: 'qualifiedName' },
+   * );
+   * ```
+   */
+  delete(
+    domainID: string,
+    params: DomainDeleteParams,
+    options?: RequestOptions,
+  ): APIPromise<DomainDeleteResponse> {
+    const { qualifiedName } = params;
+    return this._client.delete(path`/servers/${qualifiedName}/domains/${domainID}`, options);
+  }
+}
+
+export interface DomainCreateResponse {
+  id: string;
+
+  allowUnauthenticated: boolean;
+
+  cnameTarget: string | null;
+
+  createdAt: string;
+
+  hostname: string;
+
+  requiresConfig: boolean;
+
+  status: 'pending_validation' | 'pending' | 'active' | 'failed' | null;
+
+  subdomain: string | null;
+
+  type: 'managed' | 'custom';
+
+  updatedAt: string;
+
+  validation: DomainCreateResponse.Validation | null;
+}
+
+export namespace DomainCreateResponse {
+  export interface Validation {
+    records: Array<Validation.Record>;
+
+    type: string;
+  }
+
+  export namespace Validation {
+    export interface Record {
+      name: string;
+
+      value: string;
+    }
+  }
+}
+
+export interface DomainUpdateResponse {
+  id: string;
+
+  allowUnauthenticated: boolean;
+
+  cnameTarget: string | null;
+
+  createdAt: string;
+
+  hostname: string;
+
+  requiresConfig: boolean;
+
+  status: 'pending_validation' | 'pending' | 'active' | 'failed' | null;
+
+  subdomain: string | null;
+
+  type: 'managed' | 'custom';
+
+  updatedAt: string;
+
+  validation: DomainUpdateResponse.Validation | null;
+}
+
+export namespace DomainUpdateResponse {
+  export interface Validation {
+    records: Array<Validation.Record>;
+
+    type: string;
+  }
+
+  export namespace Validation {
+    export interface Record {
+      name: string;
+
+      value: string;
+    }
+  }
+}
+
+export interface DomainListResponse {
+  domains: Array<DomainListResponse.Domain>;
+}
+
+export namespace DomainListResponse {
+  export interface Domain {
+    id: string;
+
+    allowUnauthenticated: boolean;
+
+    cnameTarget: string | null;
+
+    createdAt: string;
+
+    hostname: string;
+
+    requiresConfig: boolean;
+
+    status: 'pending_validation' | 'pending' | 'active' | 'failed' | null;
+
+    subdomain: string | null;
+
+    type: 'managed' | 'custom';
+
+    updatedAt: string;
+
+    validation: Domain.Validation | null;
+  }
+
+  export namespace Domain {
+    export interface Validation {
+      records: Array<Validation.Record>;
+
+      type: string;
+    }
+
+    export namespace Validation {
+      export interface Record {
+        name: string;
+
+        value: string;
+      }
+    }
+  }
+}
+
+export interface DomainDeleteResponse {
+  success: boolean;
+}
+
+export type DomainCreateParams = DomainCreateParams.Variant0 | DomainCreateParams.Variant1;
+
+export declare namespace DomainCreateParams {
+  export interface Variant0 {
+    subdomain: string;
+
+    type: 'managed';
+  }
+
+  export interface Variant1 {
+    hostname: string;
+
+    type: 'custom';
+  }
+}
+
+export interface DomainUpdateParams {
+  /**
+   * Path param: The server's qualified name (e.g. 'namespace/server' or 'namespace'
+   * for namespace-only servers). Use %2F to encode the slash.
+   */
+  qualifiedName: string;
+
+  /**
+   * Body param
+   */
+  allowUnauthenticated?: boolean;
+
+  /**
+   * Body param
+   */
+  requiresConfig?: boolean;
+
+  /**
+   * Body param
+   */
+  subdomain?: string;
+}
+
+export interface DomainDeleteParams {
+  /**
+   * The server's qualified name (e.g. 'namespace/server' or 'namespace' for
+   * namespace-only servers). Use %2F to encode the slash.
+   */
+  qualifiedName: string;
+}
+
+export declare namespace Domains {
+  export {
+    type DomainCreateResponse as DomainCreateResponse,
+    type DomainUpdateResponse as DomainUpdateResponse,
+    type DomainListResponse as DomainListResponse,
+    type DomainDeleteResponse as DomainDeleteResponse,
+    type DomainCreateParams as DomainCreateParams,
+    type DomainUpdateParams as DomainUpdateParams,
+    type DomainDeleteParams as DomainDeleteParams,
+  };
+}

package/src/resources/servers/index.ts

@@ -9,57 +9,39 @@ export {
   type StdioDeployPayload,
   type DeploymentListResponse,
   type DeploymentDeployResponse,
-  type DeploymentDeployByNamespaceResponse,
   type DeploymentGetResponse,
-  type DeploymentGetByNamespaceResponse,
-  type DeploymentListByNamespaceResponse,
   type DeploymentResumeResponse,
-  type DeploymentResumeByNamespaceResponse,
   type DeploymentStreamResponse,
-  type DeploymentStreamByNamespaceResponse,
-  type DeploymentListParams,
   type DeploymentDeployParams,
-  type DeploymentDeployByNamespaceParams,
   type DeploymentGetParams,
-  type DeploymentGetByNamespaceParams,
   type DeploymentResumeParams,
-  type DeploymentResumeByNamespaceParams,
   type DeploymentStreamParams,
-  type DeploymentStreamByNamespaceParams,
 } from './deployments';
 export {
-  Logs,
-  type LogListResponse,
-  type LogListByNamespaceResponse,
-  type LogListParams,
-  type LogListByNamespaceParams,
-} from './logs';
+  Domains,
+  type DomainCreateResponse,
+  type DomainUpdateResponse,
+  type DomainListResponse,
+  type DomainDeleteResponse,
+  type DomainCreateParams,
+  type DomainUpdateParams,
+  type DomainDeleteParams,
+} from './domains';
+export { Logs, type LogListResponse, type LogListParams } from './logs';
 export {
   Repo,
   type RepoDeleteResponse,
-  type RepoDeleteByNamespaceResponse,
   type RepoGetResponse,
-  type RepoGetByNamespaceResponse,
   type RepoSetResponse,
-  type RepoSetByNamespaceResponse,
-  type RepoDeleteParams,
-  type RepoGetParams,
   type RepoSetParams,
-  type RepoSetByNamespaceParams,
 } from './repo';
 export {
   Secrets,
   type SecretListResponse,
   type SecretDeleteResponse,
-  type SecretDeleteByNamespaceResponse,
-  type SecretListByNamespaceResponse,
   type SecretSetResponse,
-  type SecretSetByNamespaceResponse,
-  type SecretListParams,
   type SecretDeleteParams,
-  type SecretDeleteByNamespaceParams,
   type SecretSetParams,
-  type SecretSetByNamespaceParams,
 } from './secrets';
 export {
   Servers,
@@ -70,17 +52,9 @@ export {
   type ServerUpdateResponse,
   type ServerListResponse,
   type ServerDeleteResponse,
-  type ServerCreateByNamespaceResponse,
   type ServerGetResponse,
-  type ServerGetByNamespaceResponse,
-  type ServerUpdateByNamespaceResponse,
   type ServerCreateParams,
   type ServerUpdateParams,
   type ServerListParams,
-  type ServerDeleteParams,
-  type ServerCreateByNamespaceParams,
-  type ServerDownloadParams,
-  type ServerGetParams,
-  type ServerUpdateByNamespaceParams,
   type ServerListResponsesSmitheryPage,
 } from './servers';

package/src/resources/servers/logs.ts

@@ -7,38 +7,21 @@ import { path } from '../../internal/utils/path';
 
 export class Logs extends APIResource {
   /**
-   * Fetch recent runtime logs for the server's deployed Worker, grouped by
-   * invocation (requires ownership).
+   * Fetch recent runtime logs grouped by invocation.
    *
    * @example
    * ```ts
-   * const logs = await client.servers.logs.list('server', {
-   *   namespace: 'namespace',
-   * });
-   * ```
-   */
-  list(server: string, params: LogListParams, options?: RequestOptions): APIPromise<LogListResponse> {
-    const { namespace, ...query } = params;
-    return this._client.get(path`/servers/${namespace}/${server}/logs`, { query, ...options });
-  }
-
-  /**
-   * Fetch recent runtime logs for the server's deployed Worker, grouped by
-   * invocation (requires ownership).
-   *
-   * @example
-   * ```ts
-   * const response = await client.servers.logs.listByNamespace(
-   *   'namespace',
+   * const logs = await client.servers.logs.list(
+   *   'qualifiedName',
    * );
    * ```
    */
-  listByNamespace(
-    namespace: string,
-    query: LogListByNamespaceParams | null | undefined = {},
+  list(
+    qualifiedName: string,
+    query: LogListParams | null | undefined = {},
     options?: RequestOptions,
-  ): APIPromise<LogListByNamespaceResponse> {
-    return this._client.get(path`/servers/${namespace}/logs`, { query, ...options });
+  ): APIPromise<LogListResponse> {
+    return this._client.get(path`/servers/${qualifiedName}/logs`, { query, ...options });
   }
 }
 
@@ -107,94 +90,7 @@ export namespace LogListResponse {
   }
 }
 
-export interface LogListByNamespaceResponse {
-  invocations: Array<LogListByNamespaceResponse.Invocation>;
-
-  /**
-   * Total invocations matching query
-   */
-  total: number;
-}
-
-export namespace LogListByNamespaceResponse {
-  export interface Invocation {
-    id: string;
-
-    duration: Invocation.Duration;
-
-    exceptions: Array<Invocation.Exception>;
-
-    logs: Array<Invocation.Log>;
-
-    request: Invocation.Request;
-
-    response: Invocation.Response;
-
-    timestamp: string;
-  }
-
-  export namespace Invocation {
-    export interface Duration {
-      cpuMs: number;
-
-      wallMs: number;
-    }
-
-    export interface Exception {
-      message: string;
-
-      name: string;
-
-      timestamp: string;
-
-      stack?: string;
-    }
-
-    export interface Log {
-      level: string;
-
-      message: string;
-
-      timestamp: string;
-    }
-
-    export interface Request {
-      method: string;
-
-      url: string;
-    }
-
-    export interface Response {
-      outcome: string;
-
-      status: number;
-    }
-  }
-}
-
 export interface LogListParams {
-  /**
-   * Path param
-   */
-  namespace: string;
-
-  /**
-   * Query param: Start of time range (ISO 8601).
-   */
-  from?: string;
-
-  /**
-   * Query param: Max invocations to return. Defaults to 50.
-   */
-  limit?: number;
-
-  /**
-   * Query param: End of time range (ISO 8601).
-   */
-  to?: string;
-}
-
-export interface LogListByNamespaceParams {
   /**
    * Start of time range (ISO 8601).
    */
@@ -212,10 +108,5 @@ export interface LogListByNamespaceParams {
 }
 
 export declare namespace Logs {
-  export {
-    type LogListResponse as LogListResponse,
-    type LogListByNamespaceResponse as LogListByNamespaceResponse,
-    type LogListParams as LogListParams,
-    type LogListByNamespaceParams as LogListByNamespaceParams,
-  };
+  export { type LogListResponse as LogListResponse, type LogListParams as LogListParams };
 }